a new start

assets/bower_components/MathJax/es5/input/tex/extensions/action.js

@@ -0,0 +1,137 @@
+!(function (t) {
+	var e = {};
+	function a(o) {
+		if (e[o]) return e[o].exports;
+		var n = (e[o] = { i: o, l: !1, exports: {} });
+		return t[o].call(n.exports, n, n.exports, a), (n.l = !0), n.exports;
+	}
+	(a.m = t),
+		(a.c = e),
+		(a.d = function (t, e, o) {
+			a.o(t, e) || Object.defineProperty(t, e, { enumerable: !0, get: o });
+		}),
+		(a.r = function (t) {
+			"undefined" != typeof Symbol &&
+				Symbol.toStringTag &&
+				Object.defineProperty(t, Symbol.toStringTag, { value: "Module" }),
+				Object.defineProperty(t, "__esModule", { value: !0 });
+		}),
+		(a.t = function (t, e) {
+			if ((1 & e && (t = a(t)), 8 & e)) return t;
+			if (4 & e && "object" == typeof t && t && t.__esModule) return t;
+			var o = Object.create(null);
+			if (
+				(a.r(o),
+				Object.defineProperty(o, "default", { enumerable: !0, value: t }),
+				2 & e && "string" != typeof t)
+			)
+				for (var n in t)
+					a.d(
+						o,
+						n,
+						function (e) {
+							return t[e];
+						}.bind(null, n),
+					);
+			return o;
+		}),
+		(a.n = function (t) {
+			var e =
+				t && t.__esModule
+					? function () {
+							return t.default;
+						}
+					: function () {
+							return t;
+						};
+			return a.d(e, "a", e), e;
+		}),
+		(a.o = function (t, e) {
+			return Object.prototype.hasOwnProperty.call(t, e);
+		}),
+		(a.p = ""),
+		a((a.s = 6));
+})([
+	function (t, e, a) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.isObject = MathJax._.components.global.isObject),
+			(e.combineConfig = MathJax._.components.global.combineConfig),
+			(e.combineDefaults = MathJax._.components.global.combineDefaults),
+			(e.combineWithMathJax = MathJax._.components.global.combineWithMathJax),
+			(e.MathJax = MathJax._.components.global.MathJax);
+	},
+	function (t, e, a) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.ActionConfiguration = e.ActionMethods = void 0);
+		var o = a(2),
+			n = a(3),
+			i = a(4),
+			r = a(5);
+		(e.ActionMethods = {}),
+			(e.ActionMethods.Macro = r.default.Macro),
+			(e.ActionMethods.Toggle = function (t, e) {
+				for (var a, o = []; "\\endtoggle" !== (a = t.GetArgument(e)); )
+					o.push(new n.default(a, t.stack.env, t.configuration).mml());
+				t.Push(t.create("node", "maction", o, { actiontype: "toggle" }));
+			}),
+			(e.ActionMethods.Mathtip = function (t, e) {
+				var a = t.ParseArg(e),
+					o = t.ParseArg(e);
+				t.Push(t.create("node", "maction", [a, o], { actiontype: "tooltip" }));
+			}),
+			new i.CommandMap(
+				"action-macros",
+				{
+					toggle: "Toggle",
+					mathtip: "Mathtip",
+					texttip: ["Macro", "\\mathtip{#1}{\\text{#2}}", 2],
+				},
+				e.ActionMethods,
+			),
+			(e.ActionConfiguration = o.Configuration.create("action", {
+				handler: { macro: ["action-macros"] },
+			}));
+	},
+	function (t, e, a) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.Configuration = MathJax._.input.tex.Configuration.Configuration),
+			(e.ConfigurationHandler =
+				MathJax._.input.tex.Configuration.ConfigurationHandler),
+			(e.ParserConfiguration =
+				MathJax._.input.tex.Configuration.ParserConfiguration);
+	},
+	function (t, e, a) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.default = MathJax._.input.tex.TexParser.default);
+	},
+	function (t, e, a) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.AbstractSymbolMap = MathJax._.input.tex.SymbolMap.AbstractSymbolMap),
+			(e.RegExpMap = MathJax._.input.tex.SymbolMap.RegExpMap),
+			(e.AbstractParseMap = MathJax._.input.tex.SymbolMap.AbstractParseMap),
+			(e.CharacterMap = MathJax._.input.tex.SymbolMap.CharacterMap),
+			(e.DelimiterMap = MathJax._.input.tex.SymbolMap.DelimiterMap),
+			(e.MacroMap = MathJax._.input.tex.SymbolMap.MacroMap),
+			(e.CommandMap = MathJax._.input.tex.SymbolMap.CommandMap),
+			(e.EnvironmentMap = MathJax._.input.tex.SymbolMap.EnvironmentMap);
+	},
+	function (t, e, a) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.default = MathJax._.input.tex.base.BaseMethods.default);
+	},
+	function (t, e, a) {
+		"use strict";
+		a.r(e);
+		var o = a(0),
+			n = a(1);
+		Object(o.combineWithMathJax)({
+			_: { input: { tex: { action: { ActionConfiguration: n } } } },
+		});
+	},
+]);

assets/bower_components/MathJax/es5/input/tex/extensions/amscd.js

@@ -0,0 +1,349 @@
+!(function (e) {
+	var t = {};
+	function a(n) {
+		if (t[n]) return t[n].exports;
+		var r = (t[n] = { i: n, l: !1, exports: {} });
+		return e[n].call(r.exports, r, r.exports, a), (r.l = !0), r.exports;
+	}
+	(a.m = e),
+		(a.c = t),
+		(a.d = function (e, t, n) {
+			a.o(e, t) || Object.defineProperty(e, t, { enumerable: !0, get: n });
+		}),
+		(a.r = function (e) {
+			"undefined" != typeof Symbol &&
+				Symbol.toStringTag &&
+				Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }),
+				Object.defineProperty(e, "__esModule", { value: !0 });
+		}),
+		(a.t = function (e, t) {
+			if ((1 & t && (e = a(e)), 8 & t)) return e;
+			if (4 & t && "object" == typeof e && e && e.__esModule) return e;
+			var n = Object.create(null);
+			if (
+				(a.r(n),
+				Object.defineProperty(n, "default", { enumerable: !0, value: e }),
+				2 & t && "string" != typeof e)
+			)
+				for (var r in e)
+					a.d(
+						n,
+						r,
+						function (t) {
+							return e[t];
+						}.bind(null, r),
+					);
+			return n;
+		}),
+		(a.n = function (e) {
+			var t =
+				e && e.__esModule
+					? function () {
+							return e.default;
+						}
+					: function () {
+							return e;
+						};
+			return a.d(t, "a", t), t;
+		}),
+		(a.o = function (e, t) {
+			return Object.prototype.hasOwnProperty.call(e, t);
+		}),
+		(a.p = ""),
+		a((a.s = 11));
+})([
+	function (e, t, a) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.isObject = MathJax._.components.global.isObject),
+			(t.combineConfig = MathJax._.components.global.combineConfig),
+			(t.combineDefaults = MathJax._.components.global.combineDefaults),
+			(t.combineWithMathJax = MathJax._.components.global.combineWithMathJax),
+			(t.MathJax = MathJax._.components.global.MathJax);
+	},
+	function (e, t, a) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 });
+		var n = a(7),
+			r = a(8),
+			o = a(9),
+			i = a(10),
+			c = {
+				CD: function (e, t) {
+					e.Push(t);
+					var a = e.itemFactory.create("array"),
+						n = e.configuration.options.amscd;
+					return (
+						a.setProperties({
+							minw: e.stack.env.CD_minw || n.harrowsize,
+							minh: e.stack.env.CD_minh || n.varrowsize,
+						}),
+						(a.arraydef = {
+							columnalign: "center",
+							columnspacing: n.colspace,
+							rowspacing: n.rowspace,
+							displaystyle: !0,
+						}),
+						a
+					);
+				},
+				arrow: function (e, t) {
+					var a = e.string.charAt(e.i);
+					if (!a.match(/[><VA.|=]/)) return r.Other(e, t);
+					e.i++;
+					var l = e.stack.Top();
+					(l.isKind("array") && !l.Size()) ||
+						(c.cell(e, t), (l = e.stack.Top()));
+					for (
+						var s,
+							u = l,
+							d = u.table.length % 2 == 1,
+							m = (u.row.length + (d ? 0 : 1)) % 2;
+						m;
+					)
+						c.cell(e, t), m--;
+					var p = { minsize: u.getProperty("minw"), stretchy: !0 },
+						f = {
+							minsize: u.getProperty("minh"),
+							stretchy: !0,
+							symmetric: !0,
+							lspace: 0,
+							rspace: 0,
+						};
+					if ("." === a);
+					else if ("|" === a) s = e.create("token", "mo", f, "\u2225");
+					else if ("=" === a) s = e.create("token", "mo", p, "=");
+					else {
+						var M = { ">": "\u2192", "<": "\u2190", V: "\u2193", A: "\u2191" }[
+								a
+							],
+							h = e.GetUpTo(t + a, a),
+							b = e.GetUpTo(t + a, a);
+						if (">" === a || "<" === a) {
+							if (
+								((s = e.create("token", "mo", p, M)),
+								h || (h = "\\kern " + u.getProperty("minw")),
+								h || b)
+							) {
+								var _ = { width: ".67em", lspace: ".33em" };
+								if (((s = e.create("node", "munderover", [s])), h)) {
+									var x = new n.default(h, e.stack.env, e.configuration).mml(),
+										g = e.create("node", "mpadded", [x], _);
+									i.default.setAttribute(g, "voffset", ".1em"),
+										i.default.setChild(s, s.over, g);
+								}
+								if (b) {
+									var v = new n.default(b, e.stack.env, e.configuration).mml();
+									i.default.setChild(
+										s,
+										s.under,
+										e.create("node", "mpadded", [v], _),
+									);
+								}
+								e.configuration.options.amscd.hideHorizontalLabels &&
+									(s = e.create("node", "mpadded", s, {
+										depth: 0,
+										height: ".67em",
+									}));
+							}
+						} else {
+							var C = e.create("token", "mo", f, M);
+							(s = C),
+								(h || b) &&
+									((s = e.create("node", "mrow")),
+									h &&
+										i.default.appendChildren(s, [
+											new n.default(
+												"\\scriptstyle\\llap{" + h + "}",
+												e.stack.env,
+												e.configuration,
+											).mml(),
+										]),
+									(C.texClass = o.TEXCLASS.ORD),
+									i.default.appendChildren(s, [C]),
+									b &&
+										i.default.appendChildren(s, [
+											new n.default(
+												"\\scriptstyle\\rlap{" + b + "}",
+												e.stack.env,
+												e.configuration,
+											).mml(),
+										]));
+						}
+					}
+					s && e.Push(s), c.cell(e, t);
+				},
+				cell: function (e, t) {
+					var a = e.stack.Top();
+					(a.table || []).length % 2 == 0 &&
+						0 === (a.row || []).length &&
+						e.Push(
+							e.create("node", "mpadded", [], {
+								height: "8.5pt",
+								depth: "2pt",
+							}),
+						),
+						e.Push(
+							e.itemFactory
+								.create("cell")
+								.setProperties({ isEntry: !0, name: t }),
+						);
+				},
+				minCDarrowwidth: function (e, t) {
+					e.stack.env.CD_minw = e.GetDimen(t);
+				},
+				minCDarrowheight: function (e, t) {
+					e.stack.env.CD_minh = e.GetDimen(t);
+				},
+			};
+		t.default = c;
+	},
+	function (e, t, a) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.AmsCdConfiguration = void 0);
+		var n = a(3);
+		a(4),
+			(t.AmsCdConfiguration = n.Configuration.create("amscd", {
+				handler: {
+					character: ["amscd_special"],
+					macro: ["amscd_macros"],
+					environment: ["amscd_environment"],
+				},
+				options: {
+					amscd: {
+						colspace: "5pt",
+						rowspace: "5pt",
+						harrowsize: "2.75em",
+						varrowsize: "1.75em",
+						hideHorizontalLabels: !1,
+					},
+				},
+			}));
+	},
+	function (e, t, a) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.Configuration = MathJax._.input.tex.Configuration.Configuration),
+			(t.ConfigurationHandler =
+				MathJax._.input.tex.Configuration.ConfigurationHandler),
+			(t.ParserConfiguration =
+				MathJax._.input.tex.Configuration.ParserConfiguration);
+	},
+	function (e, t, a) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 });
+		var n = a(5),
+			r = a(6),
+			o = a(1);
+		new n.EnvironmentMap(
+			"amscd_environment",
+			r.default.environment,
+			{ CD: "CD" },
+			o.default,
+		),
+			new n.CommandMap(
+				"amscd_macros",
+				{
+					minCDarrowwidth: "minCDarrowwidth",
+					minCDarrowheight: "minCDarrowheight",
+				},
+				o.default,
+			),
+			new n.MacroMap("amscd_special", { "@": "arrow" }, o.default);
+	},
+	function (e, t, a) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.AbstractSymbolMap = MathJax._.input.tex.SymbolMap.AbstractSymbolMap),
+			(t.RegExpMap = MathJax._.input.tex.SymbolMap.RegExpMap),
+			(t.AbstractParseMap = MathJax._.input.tex.SymbolMap.AbstractParseMap),
+			(t.CharacterMap = MathJax._.input.tex.SymbolMap.CharacterMap),
+			(t.DelimiterMap = MathJax._.input.tex.SymbolMap.DelimiterMap),
+			(t.MacroMap = MathJax._.input.tex.SymbolMap.MacroMap),
+			(t.CommandMap = MathJax._.input.tex.SymbolMap.CommandMap),
+			(t.EnvironmentMap = MathJax._.input.tex.SymbolMap.EnvironmentMap);
+	},
+	function (e, t, a) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.default = MathJax._.input.tex.ParseMethods.default);
+	},
+	function (e, t, a) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.default = MathJax._.input.tex.TexParser.default);
+	},
+	function (e, t, a) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.Other = MathJax._.input.tex.base.BaseConfiguration.Other),
+			(t.BaseTags = MathJax._.input.tex.base.BaseConfiguration.BaseTags),
+			(t.BaseConfiguration =
+				MathJax._.input.tex.base.BaseConfiguration.BaseConfiguration);
+	},
+	function (e, t, a) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.TEXCLASS = MathJax._.core.MmlTree.MmlNode.TEXCLASS),
+			(t.TEXCLASSNAMES = MathJax._.core.MmlTree.MmlNode.TEXCLASSNAMES),
+			(t.indentAttributes = MathJax._.core.MmlTree.MmlNode.indentAttributes),
+			(t.AbstractMmlNode = MathJax._.core.MmlTree.MmlNode.AbstractMmlNode),
+			(t.AbstractMmlTokenNode =
+				MathJax._.core.MmlTree.MmlNode.AbstractMmlTokenNode),
+			(t.AbstractMmlLayoutNode =
+				MathJax._.core.MmlTree.MmlNode.AbstractMmlLayoutNode),
+			(t.AbstractMmlBaseNode =
+				MathJax._.core.MmlTree.MmlNode.AbstractMmlBaseNode),
+			(t.AbstractMmlEmptyNode =
+				MathJax._.core.MmlTree.MmlNode.AbstractMmlEmptyNode),
+			(t.TextNode = MathJax._.core.MmlTree.MmlNode.TextNode),
+			(t.XMLNode = MathJax._.core.MmlTree.MmlNode.XMLNode);
+	},
+	function (e, t, a) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.default = MathJax._.input.tex.NodeUtil.default);
+	},
+	function (e, t, a) {
+		"use strict";
+		a.r(t);
+		var n = a(0),
+			r = a(2),
+			o = a(1);
+		Object(n.combineWithMathJax)({
+			_: {
+				input: { tex: { amscd: { AmsCdConfiguration: r, AmsCdMethods: o } } },
+			},
+		}),
+			(function (e, t, a) {
+				var r,
+					o,
+					i,
+					c = MathJax.config.tex;
+				if (c && c.packages) {
+					var l = c.packages,
+						s = l.indexOf(e);
+					s >= 0 && (l[s] = t),
+						a &&
+							c[e] &&
+							(Object(n.combineConfig)(
+								c,
+								((r = {}),
+								(o = t),
+								(i = c[e]),
+								o in r
+									? Object.defineProperty(r, o, {
+											value: i,
+											enumerable: !0,
+											configurable: !0,
+											writable: !0,
+										})
+									: (r[o] = i),
+								r),
+							),
+							delete c[e]);
+				}
+			})("amsCd", "amscd", !0);
+	},
+]);

assets/bower_components/MathJax/es5/input/tex/extensions/autoload.js

@@ -0,0 +1,354 @@
+!(function (e) {
+	var t = {};
+	function o(a) {
+		if (t[a]) return t[a].exports;
+		var r = (t[a] = { i: a, l: !1, exports: {} });
+		return e[a].call(r.exports, r, r.exports, o), (r.l = !0), r.exports;
+	}
+	(o.m = e),
+		(o.c = t),
+		(o.d = function (e, t, a) {
+			o.o(e, t) || Object.defineProperty(e, t, { enumerable: !0, get: a });
+		}),
+		(o.r = function (e) {
+			"undefined" != typeof Symbol &&
+				Symbol.toStringTag &&
+				Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }),
+				Object.defineProperty(e, "__esModule", { value: !0 });
+		}),
+		(o.t = function (e, t) {
+			if ((1 & t && (e = o(e)), 8 & t)) return e;
+			if (4 & t && "object" == typeof e && e && e.__esModule) return e;
+			var a = Object.create(null);
+			if (
+				(o.r(a),
+				Object.defineProperty(a, "default", { enumerable: !0, value: e }),
+				2 & t && "string" != typeof e)
+			)
+				for (var r in e)
+					o.d(
+						a,
+						r,
+						function (t) {
+							return e[t];
+						}.bind(null, r),
+					);
+			return a;
+		}),
+		(o.n = function (e) {
+			var t =
+				e && e.__esModule
+					? function () {
+							return e.default;
+						}
+					: function () {
+							return e;
+						};
+			return o.d(t, "a", t), t;
+		}),
+		(o.o = function (e, t) {
+			return Object.prototype.hasOwnProperty.call(e, t);
+		}),
+		(o.p = ""),
+		o((o.s = 8));
+})([
+	function (e, t, o) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.isObject = MathJax._.components.global.isObject),
+			(t.combineConfig = MathJax._.components.global.combineConfig),
+			(t.combineDefaults = MathJax._.components.global.combineDefaults),
+			(t.combineWithMathJax = MathJax._.components.global.combineWithMathJax),
+			(t.MathJax = MathJax._.components.global.MathJax);
+	},
+	function (e, t, o) {
+		"use strict";
+		var a =
+				(this && this.__read) ||
+				function (e, t) {
+					var o = "function" == typeof Symbol && e[Symbol.iterator];
+					if (!o) return e;
+					var a,
+						r,
+						n = o.call(e),
+						i = [];
+					try {
+						for (; (void 0 === t || t-- > 0) && !(a = n.next()).done; )
+							i.push(a.value);
+					} catch (e) {
+						r = { error: e };
+					} finally {
+						try {
+							a && !a.done && (o = n.return) && o.call(n);
+						} finally {
+							if (r) throw r.error;
+						}
+					}
+					return i;
+				},
+			r =
+				(this && this.__values) ||
+				function (e) {
+					var t = "function" == typeof Symbol && Symbol.iterator,
+						o = t && e[t],
+						a = 0;
+					if (o) return o.call(e);
+					if (e && "number" == typeof e.length)
+						return {
+							next: function () {
+								return (
+									e && a >= e.length && (e = void 0),
+									{ value: e && e[a++], done: !e }
+								);
+							},
+						};
+					throw new TypeError(
+						t ? "Object is not iterable." : "Symbol.iterator is not defined.",
+					);
+				};
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.AutoloadConfiguration = void 0);
+		var n = o(2),
+			i = o(3),
+			l = o(4),
+			u = o(5),
+			c = o(6),
+			s = o(7);
+		function p(e, t, o, n) {
+			var i, l, s, p;
+			if (c.Package.packages.has(e.options.require.prefix + o)) {
+				var x = e.options.autoload[o],
+					M = a(2 === x.length && Array.isArray(x[0]) ? x : [x, []], 2),
+					b = M[0],
+					h = M[1];
+				try {
+					for (var y = r(b), m = y.next(); !m.done; m = y.next()) {
+						var _ = m.value;
+						f.remove(_);
+					}
+				} catch (e) {
+					i = { error: e };
+				} finally {
+					try {
+						m && !m.done && (l = y.return) && l.call(y);
+					} finally {
+						if (i) throw i.error;
+					}
+				}
+				try {
+					for (var g = r(h), v = g.next(); !v.done; v = g.next()) {
+						var O = v.value;
+						d.remove(O);
+					}
+				} catch (e) {
+					s = { error: e };
+				} finally {
+					try {
+						v && !v.done && (p = g.return) && p.call(g);
+					} finally {
+						if (s) throw s.error;
+					}
+				}
+				(e.string =
+					(n ? t : "\\begin{" + t.slice(1) + "}") + e.string.slice(e.i)),
+					(e.i = 0);
+			}
+			u.RequireLoad(e, o);
+		}
+		var f = new i.CommandMap("autoload-macros", {}, {}),
+			d = new i.CommandMap("autoload-environments", {}, {});
+		t.AutoloadConfiguration = n.Configuration.create("autoload", {
+			handler: {
+				macro: ["autoload-macros"],
+				environment: ["autoload-environments"],
+			},
+			options: {
+				autoload: s.expandable({
+					action: ["toggle", "mathtip", "texttip"],
+					amscd: [[], ["CD"]],
+					bbox: ["bbox"],
+					boldsymbol: ["boldsymbol"],
+					braket: [
+						"bra",
+						"ket",
+						"braket",
+						"set",
+						"Bra",
+						"Ket",
+						"Braket",
+						"Set",
+						"ketbra",
+						"Ketbra",
+					],
+					bussproofs: [[], ["prooftree"]],
+					cancel: ["cancel", "bcancel", "xcancel", "cancelto"],
+					color: ["color", "definecolor", "textcolor", "colorbox", "fcolorbox"],
+					enclose: ["enclose"],
+					extpfeil: [
+						"xtwoheadrightarrow",
+						"xtwoheadleftarrow",
+						"xmapsto",
+						"xlongequal",
+						"xtofrom",
+						"Newextarrow",
+					],
+					html: ["href", "class", "style", "cssId"],
+					mhchem: ["ce", "pu"],
+					newcommand: [
+						"newcommand",
+						"renewcommand",
+						"newenvironment",
+						"renewenvironment",
+						"def",
+						"let",
+					],
+					unicode: ["unicode"],
+					verb: ["verb"],
+				}),
+			},
+			config: function (e, t) {
+				var o,
+					n,
+					i,
+					c,
+					s,
+					x,
+					M = t.parseOptions,
+					b = M.handlers.get("macro"),
+					h = M.handlers.get("environment"),
+					y = M.options.autoload;
+				M.packageData.set("autoload", { Autoload: p });
+				try {
+					for (var m = r(Object.keys(y)), _ = m.next(); !_.done; _ = m.next()) {
+						var g = _.value,
+							v = y[g],
+							O = a(2 === v.length && Array.isArray(v[0]) ? v : [v, []], 2),
+							J = O[0],
+							C = O[1];
+						try {
+							for (
+								var P = ((i = void 0), r(J)), S = P.next();
+								!S.done;
+								S = P.next()
+							) {
+								var w = S.value;
+								(b.lookup(w) && "color" !== w) ||
+									f.add(w, new l.Macro(w, p, [g, !0]));
+							}
+						} catch (e) {
+							i = { error: e };
+						} finally {
+							try {
+								S && !S.done && (c = P.return) && c.call(P);
+							} finally {
+								if (i) throw i.error;
+							}
+						}
+						try {
+							for (
+								var k = ((s = void 0), r(C)), q = k.next();
+								!q.done;
+								q = k.next()
+							) {
+								var j = q.value;
+								h.lookup(j) || d.add(j, new l.Macro(j, p, [g, !1]));
+							}
+						} catch (e) {
+							s = { error: e };
+						} finally {
+							try {
+								q && !q.done && (x = k.return) && x.call(k);
+							} finally {
+								if (s) throw s.error;
+							}
+						}
+					}
+				} catch (e) {
+					o = { error: e };
+				} finally {
+					try {
+						_ && !_.done && (n = m.return) && n.call(m);
+					} finally {
+						if (o) throw o.error;
+					}
+				}
+				M.packageData.get("require") || u.RequireConfiguration.config(e, t);
+			},
+			init: function (e) {
+				e.options.require ||
+					s.defaultOptions(e.options, u.RequireConfiguration.options);
+			},
+			priority: 10,
+		});
+	},
+	function (e, t, o) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.Configuration = MathJax._.input.tex.Configuration.Configuration),
+			(t.ConfigurationHandler =
+				MathJax._.input.tex.Configuration.ConfigurationHandler),
+			(t.ParserConfiguration =
+				MathJax._.input.tex.Configuration.ParserConfiguration);
+	},
+	function (e, t, o) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.AbstractSymbolMap = MathJax._.input.tex.SymbolMap.AbstractSymbolMap),
+			(t.RegExpMap = MathJax._.input.tex.SymbolMap.RegExpMap),
+			(t.AbstractParseMap = MathJax._.input.tex.SymbolMap.AbstractParseMap),
+			(t.CharacterMap = MathJax._.input.tex.SymbolMap.CharacterMap),
+			(t.DelimiterMap = MathJax._.input.tex.SymbolMap.DelimiterMap),
+			(t.MacroMap = MathJax._.input.tex.SymbolMap.MacroMap),
+			(t.CommandMap = MathJax._.input.tex.SymbolMap.CommandMap),
+			(t.EnvironmentMap = MathJax._.input.tex.SymbolMap.EnvironmentMap);
+	},
+	function (e, t, o) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.Symbol = MathJax._.input.tex.Symbol.Symbol),
+			(t.Macro = MathJax._.input.tex.Symbol.Macro);
+	},
+	function (e, t, o) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.RequireLoad =
+				MathJax._.input.tex.require.RequireConfiguration.RequireLoad),
+			(t.RequireMethods =
+				MathJax._.input.tex.require.RequireConfiguration.RequireMethods),
+			(t.options = MathJax._.input.tex.require.RequireConfiguration.options),
+			(t.RequireConfiguration =
+				MathJax._.input.tex.require.RequireConfiguration.RequireConfiguration);
+	},
+	function (e, t, o) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.PackageError = MathJax._.components.package.PackageError),
+			(t.Package = MathJax._.components.package.Package);
+	},
+	function (e, t, o) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.APPEND = MathJax._.util.Options.APPEND),
+			(t.REMOVE = MathJax._.util.Options.REMOVE),
+			(t.Expandable = MathJax._.util.Options.Expandable),
+			(t.expandable = MathJax._.util.Options.expandable),
+			(t.makeArray = MathJax._.util.Options.makeArray),
+			(t.keys = MathJax._.util.Options.keys),
+			(t.copy = MathJax._.util.Options.copy),
+			(t.insert = MathJax._.util.Options.insert),
+			(t.defaultOptions = MathJax._.util.Options.defaultOptions),
+			(t.userOptions = MathJax._.util.Options.userOptions),
+			(t.selectOptions = MathJax._.util.Options.selectOptions),
+			(t.selectOptionsFromKeys = MathJax._.util.Options.selectOptionsFromKeys),
+			(t.separateOptions = MathJax._.util.Options.separateOptions);
+	},
+	function (e, t, o) {
+		"use strict";
+		o.r(t);
+		var a = o(0),
+			r = o(1);
+		Object(a.combineWithMathJax)({
+			_: { input: { tex: { autoload: { AutoloadConfiguration: r } } } },
+		});
+	},
+]);

assets/bower_components/MathJax/es5/input/tex/extensions/bbox.js

@@ -0,0 +1,182 @@
+!(function (t) {
+	var e = {};
+	function a(o) {
+		if (e[o]) return e[o].exports;
+		var n = (e[o] = { i: o, l: !1, exports: {} });
+		return t[o].call(n.exports, n, n.exports, a), (n.l = !0), n.exports;
+	}
+	(a.m = t),
+		(a.c = e),
+		(a.d = function (t, e, o) {
+			a.o(t, e) || Object.defineProperty(t, e, { enumerable: !0, get: o });
+		}),
+		(a.r = function (t) {
+			"undefined" != typeof Symbol &&
+				Symbol.toStringTag &&
+				Object.defineProperty(t, Symbol.toStringTag, { value: "Module" }),
+				Object.defineProperty(t, "__esModule", { value: !0 });
+		}),
+		(a.t = function (t, e) {
+			if ((1 & e && (t = a(t)), 8 & e)) return t;
+			if (4 & e && "object" == typeof t && t && t.__esModule) return t;
+			var o = Object.create(null);
+			if (
+				(a.r(o),
+				Object.defineProperty(o, "default", { enumerable: !0, value: t }),
+				2 & e && "string" != typeof t)
+			)
+				for (var n in t)
+					a.d(
+						o,
+						n,
+						function (e) {
+							return t[e];
+						}.bind(null, n),
+					);
+			return o;
+		}),
+		(a.n = function (t) {
+			var e =
+				t && t.__esModule
+					? function () {
+							return t.default;
+						}
+					: function () {
+							return t;
+						};
+			return a.d(e, "a", e), e;
+		}),
+		(a.o = function (t, e) {
+			return Object.prototype.hasOwnProperty.call(t, e);
+		}),
+		(a.p = ""),
+		a((a.s = 5));
+})([
+	function (t, e, a) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.isObject = MathJax._.components.global.isObject),
+			(e.combineConfig = MathJax._.components.global.combineConfig),
+			(e.combineDefaults = MathJax._.components.global.combineDefaults),
+			(e.combineWithMathJax = MathJax._.components.global.combineWithMathJax),
+			(e.MathJax = MathJax._.components.global.MathJax);
+	},
+	function (t, e, a) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.BboxConfiguration = e.BboxMethods = void 0);
+		var o = a(2),
+			n = a(3),
+			i = a(4);
+		(e.BboxMethods = {}),
+			(e.BboxMethods.BBox = function (t, e) {
+				for (
+					var a,
+						o,
+						n,
+						l = t.GetBrackets(e, ""),
+						c = t.ParseArg(e),
+						p = l.split(/,/),
+						f = 0,
+						s = p.length;
+					f < s;
+					f++
+				) {
+					var b = p[f].trim(),
+						d = b.match(/^(\.\d+|\d+(\.\d*)?)(pt|em|ex|mu|px|in|cm|mm)$/);
+					if (d) {
+						if (a)
+							throw new i.default(
+								"MultipleBBoxProperty",
+								"%1 specified twice in %2",
+								"Padding",
+								e,
+							);
+						var M = u(d[1] + d[3]);
+						M &&
+							(a = {
+								height: "+" + M,
+								depth: "+" + M,
+								lspace: M,
+								width: "+" + 2 * parseInt(d[1], 10) + d[3],
+							});
+					} else if (b.match(/^([a-z0-9]+|\#[0-9a-f]{6}|\#[0-9a-f]{3})$/i)) {
+						if (o)
+							throw new i.default(
+								"MultipleBBoxProperty",
+								"%1 specified twice in %2",
+								"Background",
+								e,
+							);
+						o = b;
+					} else if (b.match(/^[-a-z]+:/i)) {
+						if (n)
+							throw new i.default(
+								"MultipleBBoxProperty",
+								"%1 specified twice in %2",
+								"Style",
+								e,
+							);
+						n = r(b);
+					} else if ("" !== b)
+						throw new i.default(
+							"InvalidBBoxProperty",
+							'"%1" doesn\'t look like a color, a padding dimension, or a style',
+							b,
+						);
+				}
+				a && (c = t.create("node", "mpadded", [c], a)),
+					(o || n) &&
+						((a = {}),
+						o && Object.assign(a, { mathbackground: o }),
+						n && Object.assign(a, { style: n }),
+						(c = t.create("node", "mstyle", [c], a))),
+					t.Push(c);
+			});
+		var r = function (t) {
+				return t;
+			},
+			u = function (t) {
+				return t;
+			};
+		new n.CommandMap("bbox", { bbox: "BBox" }, e.BboxMethods),
+			(e.BboxConfiguration = o.Configuration.create("bbox", {
+				handler: { macro: ["bbox"] },
+			}));
+	},
+	function (t, e, a) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.Configuration = MathJax._.input.tex.Configuration.Configuration),
+			(e.ConfigurationHandler =
+				MathJax._.input.tex.Configuration.ConfigurationHandler),
+			(e.ParserConfiguration =
+				MathJax._.input.tex.Configuration.ParserConfiguration);
+	},
+	function (t, e, a) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.AbstractSymbolMap = MathJax._.input.tex.SymbolMap.AbstractSymbolMap),
+			(e.RegExpMap = MathJax._.input.tex.SymbolMap.RegExpMap),
+			(e.AbstractParseMap = MathJax._.input.tex.SymbolMap.AbstractParseMap),
+			(e.CharacterMap = MathJax._.input.tex.SymbolMap.CharacterMap),
+			(e.DelimiterMap = MathJax._.input.tex.SymbolMap.DelimiterMap),
+			(e.MacroMap = MathJax._.input.tex.SymbolMap.MacroMap),
+			(e.CommandMap = MathJax._.input.tex.SymbolMap.CommandMap),
+			(e.EnvironmentMap = MathJax._.input.tex.SymbolMap.EnvironmentMap);
+	},
+	function (t, e, a) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.default = MathJax._.input.tex.TexError.default);
+	},
+	function (t, e, a) {
+		"use strict";
+		a.r(e);
+		var o = a(0),
+			n = a(1);
+		Object(o.combineWithMathJax)({
+			_: { input: { tex: { bbox: { BboxConfiguration: n } } } },
+		});
+	},
+]);

assets/bower_components/MathJax/es5/input/tex/extensions/boldsymbol.js

@@ -0,0 +1,212 @@
+!(function (t) {
+	var e = {};
+	function o(a) {
+		if (e[a]) return e[a].exports;
+		var n = (e[a] = { i: a, l: !1, exports: {} });
+		return t[a].call(n.exports, n, n.exports, o), (n.l = !0), n.exports;
+	}
+	(o.m = t),
+		(o.c = e),
+		(o.d = function (t, e, a) {
+			o.o(t, e) || Object.defineProperty(t, e, { enumerable: !0, get: a });
+		}),
+		(o.r = function (t) {
+			"undefined" != typeof Symbol &&
+				Symbol.toStringTag &&
+				Object.defineProperty(t, Symbol.toStringTag, { value: "Module" }),
+				Object.defineProperty(t, "__esModule", { value: !0 });
+		}),
+		(o.t = function (t, e) {
+			if ((1 & e && (t = o(t)), 8 & e)) return t;
+			if (4 & e && "object" == typeof t && t && t.__esModule) return t;
+			var a = Object.create(null);
+			if (
+				(o.r(a),
+				Object.defineProperty(a, "default", { enumerable: !0, value: t }),
+				2 & e && "string" != typeof t)
+			)
+				for (var n in t)
+					o.d(
+						a,
+						n,
+						function (e) {
+							return t[e];
+						}.bind(null, n),
+					);
+			return a;
+		}),
+		(o.n = function (t) {
+			var e =
+				t && t.__esModule
+					? function () {
+							return t.default;
+						}
+					: function () {
+							return t;
+						};
+			return o.d(e, "a", e), e;
+		}),
+		(o.o = function (t, e) {
+			return Object.prototype.hasOwnProperty.call(t, e);
+		}),
+		(o.p = ""),
+		o((o.s = 7));
+})([
+	function (t, e, o) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.isObject = MathJax._.components.global.isObject),
+			(e.combineConfig = MathJax._.components.global.combineConfig),
+			(e.combineDefaults = MathJax._.components.global.combineDefaults),
+			(e.combineWithMathJax = MathJax._.components.global.combineWithMathJax),
+			(e.MathJax = MathJax._.components.global.MathJax);
+	},
+	function (t, e, o) {
+		"use strict";
+		var a =
+			(this && this.__values) ||
+			function (t) {
+				var e = "function" == typeof Symbol && Symbol.iterator,
+					o = e && t[e],
+					a = 0;
+				if (o) return o.call(t);
+				if (t && "number" == typeof t.length)
+					return {
+						next: function () {
+							return (
+								t && a >= t.length && (t = void 0),
+								{ value: t && t[a++], done: !t }
+							);
+						},
+					};
+				throw new TypeError(
+					e ? "Object is not iterable." : "Symbol.iterator is not defined.",
+				);
+			};
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.BoldsymbolConfiguration =
+				e.rewriteBoldTokens =
+				e.createBoldToken =
+				e.BoldsymbolMethods =
+					void 0);
+		var n = o(2),
+			r = o(3),
+			i = o(4),
+			l = o(5),
+			u = o(6),
+			s = {};
+		function c(t, e, o, a) {
+			var n = u.NodeFactory.createToken(t, e, o, a);
+			return (
+				"mtext" !== e &&
+					t.configuration.parser.stack.env.boldsymbol &&
+					(r.default.setProperty(n, "fixBold", !0),
+					t.configuration.addNode("fixBold", n)),
+				n
+			);
+		}
+		function d(t) {
+			var e, o;
+			try {
+				for (
+					var n = a(t.data.getList("fixBold")), l = n.next();
+					!l.done;
+					l = n.next()
+				) {
+					var u = l.value;
+					if (r.default.getProperty(u, "fixBold")) {
+						var c = r.default.getAttribute(u, "mathvariant");
+						null == c
+							? r.default.setAttribute(
+									u,
+									"mathvariant",
+									i.TexConstant.Variant.BOLD,
+								)
+							: r.default.setAttribute(u, "mathvariant", s[c] || c),
+							r.default.removeProperties(u, "fixBold");
+					}
+				}
+			} catch (t) {
+				e = { error: t };
+			} finally {
+				try {
+					l && !l.done && (o = n.return) && o.call(n);
+				} finally {
+					if (e) throw e.error;
+				}
+			}
+		}
+		(s[i.TexConstant.Variant.NORMAL] = i.TexConstant.Variant.BOLD),
+			(s[i.TexConstant.Variant.ITALIC] = i.TexConstant.Variant.BOLDITALIC),
+			(s[i.TexConstant.Variant.FRAKTUR] = i.TexConstant.Variant.BOLDFRAKTUR),
+			(s[i.TexConstant.Variant.SCRIPT] = i.TexConstant.Variant.BOLDSCRIPT),
+			(s[i.TexConstant.Variant.SANSSERIF] =
+				i.TexConstant.Variant.BOLDSANSSERIF),
+			(s["-tex-calligraphic"] = "-tex-bold-calligraphic"),
+			(s["-tex-oldstyle"] = "-tex-bold-oldstyle"),
+			(e.BoldsymbolMethods = {}),
+			(e.BoldsymbolMethods.Boldsymbol = function (t, e) {
+				var o = t.stack.env.boldsymbol;
+				t.stack.env.boldsymbol = !0;
+				var a = t.ParseArg(e);
+				(t.stack.env.boldsymbol = o), t.Push(a);
+			}),
+			new l.CommandMap(
+				"boldsymbol",
+				{ boldsymbol: "Boldsymbol" },
+				e.BoldsymbolMethods,
+			),
+			(e.createBoldToken = c),
+			(e.rewriteBoldTokens = d),
+			(e.BoldsymbolConfiguration = n.Configuration.create("boldsymbol", {
+				handler: { macro: ["boldsymbol"] },
+				nodes: { token: c },
+				postprocessors: [d],
+			}));
+	},
+	function (t, e, o) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.Configuration = MathJax._.input.tex.Configuration.Configuration),
+			(e.ConfigurationHandler =
+				MathJax._.input.tex.Configuration.ConfigurationHandler),
+			(e.ParserConfiguration =
+				MathJax._.input.tex.Configuration.ParserConfiguration);
+	},
+	function (t, e, o) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.default = MathJax._.input.tex.NodeUtil.default);
+	},
+	function (t, e, o) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.TexConstant = MathJax._.input.tex.TexConstants.TexConstant);
+	},
+	function (t, e, o) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.AbstractSymbolMap = MathJax._.input.tex.SymbolMap.AbstractSymbolMap),
+			(e.RegExpMap = MathJax._.input.tex.SymbolMap.RegExpMap),
+			(e.AbstractParseMap = MathJax._.input.tex.SymbolMap.AbstractParseMap),
+			(e.CharacterMap = MathJax._.input.tex.SymbolMap.CharacterMap),
+			(e.DelimiterMap = MathJax._.input.tex.SymbolMap.DelimiterMap),
+			(e.MacroMap = MathJax._.input.tex.SymbolMap.MacroMap),
+			(e.CommandMap = MathJax._.input.tex.SymbolMap.CommandMap),
+			(e.EnvironmentMap = MathJax._.input.tex.SymbolMap.EnvironmentMap);
+	},
+	function (t, e, o) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.NodeFactory = MathJax._.input.tex.NodeFactory.NodeFactory);
+	},
+	function (t, e, o) {
+		"use strict";
+		o.r(e);
+		var a = o(0),
+			n = o(1);
+		Object(a.combineWithMathJax)({
+			_: { input: { tex: { boldsymbol: { BoldsymbolConfiguration: n } } } },
+		});
+	},
+]);

assets/bower_components/MathJax/es5/input/tex/extensions/braket.js

@@ -0,0 +1,340 @@
+!(function (e) {
+	var t = {};
+	function r(a) {
+		if (t[a]) return t[a].exports;
+		var o = (t[a] = { i: a, l: !1, exports: {} });
+		return e[a].call(o.exports, o, o.exports, r), (o.l = !0), o.exports;
+	}
+	(r.m = e),
+		(r.c = t),
+		(r.d = function (e, t, a) {
+			r.o(e, t) || Object.defineProperty(e, t, { enumerable: !0, get: a });
+		}),
+		(r.r = function (e) {
+			"undefined" != typeof Symbol &&
+				Symbol.toStringTag &&
+				Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }),
+				Object.defineProperty(e, "__esModule", { value: !0 });
+		}),
+		(r.t = function (e, t) {
+			if ((1 & t && (e = r(e)), 8 & t)) return e;
+			if (4 & t && "object" == typeof e && e && e.__esModule) return e;
+			var a = Object.create(null);
+			if (
+				(r.r(a),
+				Object.defineProperty(a, "default", { enumerable: !0, value: e }),
+				2 & t && "string" != typeof e)
+			)
+				for (var o in e)
+					r.d(
+						a,
+						o,
+						function (t) {
+							return e[t];
+						}.bind(null, o),
+					);
+			return a;
+		}),
+		(r.n = function (e) {
+			var t =
+				e && e.__esModule
+					? function () {
+							return e.default;
+						}
+					: function () {
+							return e;
+						};
+			return r.d(t, "a", t), t;
+		}),
+		(r.o = function (e, t) {
+			return Object.prototype.hasOwnProperty.call(e, t);
+		}),
+		(r.p = ""),
+		r((r.s = 12));
+})([
+	function (e, t, r) {
+		"use strict";
+		var a,
+			o =
+				(this && this.__extends) ||
+				((a = function (e, t) {
+					return (a =
+						Object.setPrototypeOf ||
+						({ __proto__: [] } instanceof Array &&
+							function (e, t) {
+								e.__proto__ = t;
+							}) ||
+						function (e, t) {
+							for (var r in t) t.hasOwnProperty(r) && (e[r] = t[r]);
+						})(e, t);
+				}),
+				function (e, t) {
+					function r() {
+						this.constructor = e;
+					}
+					a(e, t),
+						(e.prototype =
+							null === t
+								? Object.create(t)
+								: ((r.prototype = t.prototype), new r()));
+				});
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.BraketItem = void 0);
+		var n = r(6),
+			i = r(2),
+			c = r(7),
+			u = (function (e) {
+				function t() {
+					return (null !== e && e.apply(this, arguments)) || this;
+				}
+				return (
+					o(t, e),
+					Object.defineProperty(t.prototype, "kind", {
+						get: function () {
+							return "braket";
+						},
+						enumerable: !1,
+						configurable: !0,
+					}),
+					Object.defineProperty(t.prototype, "isOpen", {
+						get: function () {
+							return !0;
+						},
+						enumerable: !1,
+						configurable: !0,
+					}),
+					(t.prototype.checkItem = function (t) {
+						return t.isKind("close")
+							? [[this.factory.create("mml", this.toMml())], !0]
+							: t.isKind("mml")
+								? (this.Push(t.toMml()),
+									this.getProperty("single")
+										? [[this.toMml()], !0]
+										: n.BaseItem.fail)
+								: e.prototype.checkItem.call(this, t);
+					}),
+					(t.prototype.toMml = function () {
+						var t = e.prototype.toMml.call(this),
+							r = this.getProperty("open"),
+							a = this.getProperty("close");
+						if (this.getProperty("stretchy"))
+							return c.default.fenced(this.factory.configuration, r, t, a);
+						var o = {
+								fence: !0,
+								stretchy: !1,
+								symmetric: !0,
+								texClass: i.TEXCLASS.OPEN,
+							},
+							n = this.create("token", "mo", o, r);
+						o.texClass = i.TEXCLASS.CLOSE;
+						var u = this.create("token", "mo", o, a);
+						return this.create("node", "mrow", [n, t, u], {
+							open: r,
+							close: a,
+							texClass: i.TEXCLASS.INNER,
+						});
+					}),
+					t
+				);
+			})(n.BaseItem);
+		t.BraketItem = u;
+	},
+	function (e, t, r) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 });
+		var a = r(10),
+			o = r(2),
+			n = r(11),
+			i = {};
+		(i.Macro = a.default.Macro),
+			(i.Braket = function (e, t, r, a, o, i) {
+				var c = e.GetNext();
+				if ("" === c)
+					throw new n.default(
+						"MissingArgFor",
+						"Missing argument for %1",
+						e.currentCS,
+					);
+				var u = !0;
+				"{" === c && (e.i++, (u = !1)),
+					e.Push(
+						e.itemFactory.create("braket").setProperties({
+							barmax: i,
+							barcount: 0,
+							open: r,
+							close: a,
+							stretchy: o,
+							single: u,
+						}),
+					);
+			}),
+			(i.Bar = function (e, t) {
+				var r = "|" === t ? "|" : "\u2225",
+					a = e.stack.Top();
+				if (
+					"braket" !== a.kind ||
+					a.getProperty("barcount") >= a.getProperty("barmax")
+				) {
+					var n = e.create(
+						"token",
+						"mo",
+						{ texClass: o.TEXCLASS.ORD, stretchy: !1 },
+						r,
+					);
+					e.Push(n);
+				} else {
+					if (
+						("|" === r && "|" === e.GetNext() && (e.i++, (r = "\u2225")),
+						a.getProperty("stretchy"))
+					) {
+						var i = e.create("node", "TeXAtom", [], {
+							texClass: o.TEXCLASS.CLOSE,
+						});
+						e.Push(i),
+							a.setProperty("barcount", a.getProperty("barcount") + 1),
+							(i = e.create("token", "mo", { stretchy: !0, braketbar: !0 }, r)),
+							e.Push(i),
+							(i = e.create("node", "TeXAtom", [], {
+								texClass: o.TEXCLASS.OPEN,
+							})),
+							e.Push(i);
+					} else {
+						var c = e.create("token", "mo", { stretchy: !1, braketbar: !0 }, r);
+						e.Push(c);
+					}
+				}
+			}),
+			(t.default = i);
+	},
+	function (e, t, r) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.TEXCLASS = MathJax._.core.MmlTree.MmlNode.TEXCLASS),
+			(t.TEXCLASSNAMES = MathJax._.core.MmlTree.MmlNode.TEXCLASSNAMES),
+			(t.indentAttributes = MathJax._.core.MmlTree.MmlNode.indentAttributes),
+			(t.AbstractMmlNode = MathJax._.core.MmlTree.MmlNode.AbstractMmlNode),
+			(t.AbstractMmlTokenNode =
+				MathJax._.core.MmlTree.MmlNode.AbstractMmlTokenNode),
+			(t.AbstractMmlLayoutNode =
+				MathJax._.core.MmlTree.MmlNode.AbstractMmlLayoutNode),
+			(t.AbstractMmlBaseNode =
+				MathJax._.core.MmlTree.MmlNode.AbstractMmlBaseNode),
+			(t.AbstractMmlEmptyNode =
+				MathJax._.core.MmlTree.MmlNode.AbstractMmlEmptyNode),
+			(t.TextNode = MathJax._.core.MmlTree.MmlNode.TextNode),
+			(t.XMLNode = MathJax._.core.MmlTree.MmlNode.XMLNode);
+	},
+	function (e, t, r) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.isObject = MathJax._.components.global.isObject),
+			(t.combineConfig = MathJax._.components.global.combineConfig),
+			(t.combineDefaults = MathJax._.components.global.combineDefaults),
+			(t.combineWithMathJax = MathJax._.components.global.combineWithMathJax),
+			(t.MathJax = MathJax._.components.global.MathJax);
+	},
+	function (e, t, r) {
+		"use strict";
+		var a;
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.BraketConfiguration = void 0);
+		var o = r(5),
+			n = r(0);
+		r(8),
+			(t.BraketConfiguration = o.Configuration.create("braket", {
+				handler: { character: ["Braket-characters"], macro: ["Braket-macros"] },
+				items: ((a = {}), (a[n.BraketItem.prototype.kind] = n.BraketItem), a),
+			}));
+	},
+	function (e, t, r) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.Configuration = MathJax._.input.tex.Configuration.Configuration),
+			(t.ConfigurationHandler =
+				MathJax._.input.tex.Configuration.ConfigurationHandler),
+			(t.ParserConfiguration =
+				MathJax._.input.tex.Configuration.ParserConfiguration);
+	},
+	function (e, t, r) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.MmlStack = MathJax._.input.tex.StackItem.MmlStack),
+			(t.BaseItem = MathJax._.input.tex.StackItem.BaseItem);
+	},
+	function (e, t, r) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.default = MathJax._.input.tex.ParseUtil.default);
+	},
+	function (e, t, r) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 });
+		var a = r(9),
+			o = r(1);
+		new a.CommandMap(
+			"Braket-macros",
+			{
+				bra: ["Macro", "{\\langle {#1} \\vert}", 1],
+				ket: ["Macro", "{\\vert {#1} \\rangle}", 1],
+				braket: ["Braket", "\u27e8", "\u27e9", !1, 1 / 0],
+				set: ["Braket", "{", "}", !1, 1],
+				Bra: ["Macro", "{\\left\\langle {#1} \\right\\vert}", 1],
+				Ket: ["Macro", "{\\left\\vert {#1} \\right\\rangle}", 1],
+				Braket: ["Braket", "\u27e8", "\u27e9", !0, 1 / 0],
+				Set: ["Braket", "{", "}", !0, 1],
+				ketbra: ["Macro", "{\\vert {#1} \\rangle\\langle {#2} \\vert}", 2],
+				Ketbra: [
+					"Macro",
+					"{\\left\\vert {#1} \\right\\rangle\\left\\langle {#2} \\right\\vert}",
+					2,
+				],
+				"|": "Bar",
+			},
+			o.default,
+		),
+			new a.MacroMap("Braket-characters", { "|": "Bar" }, o.default);
+	},
+	function (e, t, r) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.AbstractSymbolMap = MathJax._.input.tex.SymbolMap.AbstractSymbolMap),
+			(t.RegExpMap = MathJax._.input.tex.SymbolMap.RegExpMap),
+			(t.AbstractParseMap = MathJax._.input.tex.SymbolMap.AbstractParseMap),
+			(t.CharacterMap = MathJax._.input.tex.SymbolMap.CharacterMap),
+			(t.DelimiterMap = MathJax._.input.tex.SymbolMap.DelimiterMap),
+			(t.MacroMap = MathJax._.input.tex.SymbolMap.MacroMap),
+			(t.CommandMap = MathJax._.input.tex.SymbolMap.CommandMap),
+			(t.EnvironmentMap = MathJax._.input.tex.SymbolMap.EnvironmentMap);
+	},
+	function (e, t, r) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.default = MathJax._.input.tex.base.BaseMethods.default);
+	},
+	function (e, t, r) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.default = MathJax._.input.tex.TexError.default);
+	},
+	function (e, t, r) {
+		"use strict";
+		r.r(t);
+		var a = r(3),
+			o = r(4),
+			n = r(0),
+			i = r(1);
+		Object(a.combineWithMathJax)({
+			_: {
+				input: {
+					tex: {
+						braket: {
+							BraketConfiguration: o,
+							BraketItems: n,
+							BraketMethods: i,
+						},
+					},
+				},
+			},
+		});
+	},
+]);

assets/bower_components/MathJax/es5/input/tex/extensions/bussproofs.js

@@ -0,0 +1,853 @@
+!(function (e) {
+	var t = {};
+	function r(o) {
+		if (t[o]) return t[o].exports;
+		var n = (t[o] = { i: o, l: !1, exports: {} });
+		return e[o].call(n.exports, n, n.exports, r), (n.l = !0), n.exports;
+	}
+	(r.m = e),
+		(r.c = t),
+		(r.d = function (e, t, o) {
+			r.o(e, t) || Object.defineProperty(e, t, { enumerable: !0, get: o });
+		}),
+		(r.r = function (e) {
+			"undefined" != typeof Symbol &&
+				Symbol.toStringTag &&
+				Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }),
+				Object.defineProperty(e, "__esModule", { value: !0 });
+		}),
+		(r.t = function (e, t) {
+			if ((1 & t && (e = r(e)), 8 & t)) return e;
+			if (4 & t && "object" == typeof e && e && e.__esModule) return e;
+			var o = Object.create(null);
+			if (
+				(r.r(o),
+				Object.defineProperty(o, "default", { enumerable: !0, value: e }),
+				2 & t && "string" != typeof e)
+			)
+				for (var n in e)
+					r.d(
+						o,
+						n,
+						function (t) {
+							return e[t];
+						}.bind(null, n),
+					);
+			return o;
+		}),
+		(r.n = function (e) {
+			var t =
+				e && e.__esModule
+					? function () {
+							return e.default;
+						}
+					: function () {
+							return e;
+						};
+			return r.d(t, "a", t), t;
+		}),
+		(r.o = function (e, t) {
+			return Object.prototype.hasOwnProperty.call(e, t);
+		}),
+		(r.p = ""),
+		r((r.s = 15));
+})([
+	function (e, t, r) {
+		"use strict";
+		var o,
+			n =
+				(this && this.__read) ||
+				function (e, t) {
+					var r = "function" == typeof Symbol && e[Symbol.iterator];
+					if (!r) return e;
+					var o,
+						n,
+						a = r.call(e),
+						i = [];
+					try {
+						for (; (void 0 === t || t-- > 0) && !(o = a.next()).done; )
+							i.push(o.value);
+					} catch (e) {
+						n = { error: e };
+					} finally {
+						try {
+							o && !o.done && (r = a.return) && r.call(a);
+						} finally {
+							if (n) throw n.error;
+						}
+					}
+					return i;
+				},
+			a =
+				(this && this.__values) ||
+				function (e) {
+					var t = "function" == typeof Symbol && Symbol.iterator,
+						r = t && e[t],
+						o = 0;
+					if (r) return r.call(e);
+					if (e && "number" == typeof e.length)
+						return {
+							next: function () {
+								return (
+									e && o >= e.length && (e = void 0),
+									{ value: e && e[o++], done: !e }
+								);
+							},
+						};
+					throw new TypeError(
+						t ? "Object is not iterable." : "Symbol.iterator is not defined.",
+					);
+				};
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.clearDocument =
+				t.saveDocument =
+				t.makeBsprAttributes =
+				t.removeProperty =
+				t.getProperty =
+				t.setProperty =
+				t.balanceRules =
+					void 0);
+		var i = r(10),
+			l = r(4),
+			u = null,
+			f = null,
+			s = function (e) {
+				return (f.root = e), u.outputJax.getBBox(f, u).w;
+			},
+			c = function (e) {
+				for (var t = 0; e && !i.default.isType(e, "mtable"); ) {
+					if (i.default.isType(e, "text")) return null;
+					i.default.isType(e, "mrow")
+						? ((e = e.childNodes[0]), (t = 0))
+						: ((e = e.parent.childNodes[t]), t++);
+				}
+				return e;
+			},
+			d = function (e, t) {
+				return e.childNodes["up" === t ? 1 : 0].childNodes[0].childNodes[0]
+					.childNodes[0].childNodes[0];
+			},
+			p = function (e, t) {
+				return e.childNodes[t].childNodes[0].childNodes[0];
+			},
+			m = function (e) {
+				return p(e, 0);
+			},
+			h = function (e) {
+				return p(e, e.childNodes.length - 1);
+			},
+			y = function (e, t) {
+				return e.childNodes["up" === t ? 0 : 1].childNodes[0].childNodes[0]
+					.childNodes[0];
+			},
+			v = function (e) {
+				for (; e && !i.default.isType(e, "mtd"); ) e = e.parent;
+				return e;
+			},
+			P = function (e) {
+				return e.parent.childNodes[e.parent.childNodes.indexOf(e) + 1];
+			},
+			g = function (e) {
+				for (; e && null == t.getProperty(e, "inference"); ) e = e.parent;
+				return e;
+			},
+			b = function (e, t, r) {
+				void 0 === r && (r = !1);
+				var o = 0;
+				if (e === t) return o;
+				if (e !== t.parent) {
+					var n = e.childNodes,
+						a = r ? n.length - 1 : 0;
+					i.default.isType(n[a], "mspace") && (o += s(n[a])), (e = t.parent);
+				}
+				if (e === t) return o;
+				var l = e.childNodes,
+					u = r ? l.length - 1 : 0;
+				return l[u] !== t && (o += s(l[u])), o;
+			},
+			x = function (e, r) {
+				void 0 === r && (r = !1);
+				var o = c(e),
+					n = y(o, t.getProperty(o, "inferenceRule"));
+				return b(e, o, r) + (s(o) - s(n)) / 2;
+			},
+			M = function (e, r, o, n) {
+				if (
+					(void 0 === n && (n = !1),
+					t.getProperty(r, "inferenceRule") || t.getProperty(r, "labelledRule"))
+				) {
+					var a = e.nodeFactory.create("node", "mrow");
+					r.parent.replaceChild(a, r), a.setChildren([r]), _(r, a), (r = a);
+				}
+				var u = n ? r.childNodes.length - 1 : 0,
+					f = r.childNodes[u];
+				i.default.isType(f, "mspace")
+					? i.default.setAttribute(
+							f,
+							"width",
+							l.default.Em(
+								l.default.dimen2em(i.default.getAttribute(f, "width")) + o,
+							),
+						)
+					: ((f = e.nodeFactory.create("node", "mspace", [], {
+							width: l.default.Em(o),
+						})),
+						n ? r.appendChild(f) : ((f.parent = r), r.childNodes.unshift(f)));
+			},
+			_ = function (e, r) {
+				["inference", "proof", "maxAdjust", "labelledRule"].forEach(
+					function (o) {
+						var n = t.getProperty(e, o);
+						null != n && (t.setProperty(r, o, n), t.removeProperty(e, o));
+					},
+				);
+			},
+			w = function (e, r, o, n, a) {
+				var i = e.nodeFactory.create("node", "mspace", [], {
+					width: l.default.Em(a),
+				});
+				if ("left" === n) {
+					var u = r.childNodes[o].childNodes[0];
+					(i.parent = u), u.childNodes.unshift(i);
+				} else r.childNodes[o].appendChild(i);
+				t.setProperty(r.parent, "sequentAdjust_" + n, a);
+			},
+			T = function (e, r) {
+				for (var o = r.pop(); r.length; ) {
+					var a = r.pop(),
+						i = n(C(o, a), 2),
+						l = i[0],
+						u = i[1];
+					t.getProperty(o.parent, "axiom") &&
+						(w(e, l < 0 ? o : a, 0, "left", Math.abs(l)),
+						w(e, u < 0 ? o : a, 2, "right", Math.abs(u))),
+						(o = a);
+				}
+			},
+			C = function (e, t) {
+				var r = s(e.childNodes[2]),
+					o = s(t.childNodes[2]);
+				return [s(e.childNodes[0]) - s(t.childNodes[0]), r - o];
+			};
+		t.balanceRules = function (e) {
+			var r, o;
+			f = new e.document.options.MathItem("", null, e.math.display);
+			var n = e.data;
+			!(function (e) {
+				var r = e.nodeLists.sequent;
+				if (r)
+					for (var o = r.length - 1, n = void 0; (n = r[o]); o--)
+						if (t.getProperty(n, "sequentProcessed"))
+							t.removeProperty(n, "sequentProcessed");
+						else {
+							var a = [],
+								i = g(n);
+							if (1 === t.getProperty(i, "inference")) {
+								for (a.push(n); 1 === t.getProperty(i, "inference"); ) {
+									i = c(i);
+									var l = m(d(i, t.getProperty(i, "inferenceRule"))),
+										u = t.getProperty(l, "inferenceRule")
+											? y(l, t.getProperty(l, "inferenceRule"))
+											: l;
+									t.getProperty(u, "sequent") &&
+										((n = u.childNodes[0]),
+										a.push(n),
+										t.setProperty(n, "sequentProcessed", !0)),
+										(i = l);
+								}
+								T(e, a);
+							}
+						}
+			})(n);
+			var i = n.nodeLists.inference || [];
+			try {
+				for (var l = a(i), u = l.next(); !u.done; u = l.next()) {
+					var s = u.value,
+						p = t.getProperty(s, "proof"),
+						_ = c(s),
+						w = d(_, t.getProperty(_, "inferenceRule")),
+						C = m(w);
+					if (t.getProperty(C, "inference")) {
+						var I = x(C);
+						if (I) {
+							M(n, C, -I);
+							var S = b(s, _, !1);
+							M(n, s, I - S);
+						}
+					}
+					var N = h(w);
+					if (null != t.getProperty(N, "inference")) {
+						var A = x(N, !0);
+						M(n, N, -A, !0);
+						var j = b(s, _, !0),
+							L = t.getProperty(s, "maxAdjust");
+						null != L && (A = Math.max(A, L));
+						var k = void 0;
+						if (!p && (k = v(s))) {
+							var O = P(k);
+							if (O) {
+								var J = n.nodeFactory.create("node", "mspace", [], {
+									width: A - j + "em",
+								});
+								O.appendChild(J), s.removeProperty("maxAdjust");
+							} else {
+								var B = g(k);
+								B &&
+									((A = t.getProperty(B, "maxAdjust")
+										? Math.max(t.getProperty(B, "maxAdjust"), A)
+										: A),
+									t.setProperty(B, "maxAdjust", A));
+							}
+						} else M(n, t.getProperty(s, "proof") ? s : s.parent, A - j, !0);
+					}
+				}
+			} catch (e) {
+				r = { error: e };
+			} finally {
+				try {
+					u && !u.done && (o = l.return) && o.call(l);
+				} finally {
+					if (r) throw r.error;
+				}
+			}
+		};
+		var I = (((o = {}).bspr_maxAdjust = !0), o);
+		(t.setProperty = function (e, t, r) {
+			i.default.setProperty(e, "bspr_" + t, r);
+		}),
+			(t.getProperty = function (e, t) {
+				return i.default.getProperty(e, "bspr_" + t);
+			}),
+			(t.removeProperty = function (e, t) {
+				e.removeProperty("bspr_" + t);
+			}),
+			(t.makeBsprAttributes = function (e) {
+				e.data.root.walkTree(function (e, t) {
+					var r = [];
+					e.getPropertyNames().forEach(function (t) {
+						!I[t] &&
+							t.match(RegExp("^bspr_")) &&
+							r.push(t + ":" + e.getProperty(t));
+					}),
+						r.length && i.default.setAttribute(e, "semantics", r.join(";"));
+				});
+			}),
+			(t.saveDocument = function (e) {
+				if (!("getBBox" in (u = e.document).outputJax))
+					throw Error(
+						"The bussproofs extension requires an output jax with a getBBox() method",
+					);
+			}),
+			(t.clearDocument = function (e) {
+				u = null;
+			});
+	},
+	function (e, t, r) {
+		"use strict";
+		var o,
+			n =
+				(this && this.__extends) ||
+				((o = function (e, t) {
+					return (o =
+						Object.setPrototypeOf ||
+						({ __proto__: [] } instanceof Array &&
+							function (e, t) {
+								e.__proto__ = t;
+							}) ||
+						function (e, t) {
+							for (var r in t) t.hasOwnProperty(r) && (e[r] = t[r]);
+						})(e, t);
+				}),
+				function (e, t) {
+					function r() {
+						this.constructor = e;
+					}
+					o(e, t),
+						(e.prototype =
+							null === t
+								? Object.create(t)
+								: ((r.prototype = t.prototype), new r()));
+				});
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.ProofTreeItem = void 0);
+		var a = r(3),
+			i = r(8),
+			l = r(9),
+			u = r(0),
+			f = (function (e) {
+				function t() {
+					var t = (null !== e && e.apply(this, arguments)) || this;
+					return (
+						(t.leftLabel = null),
+						(t.rigthLabel = null),
+						(t.innerStack = new l.default(t.factory, {}, !0)),
+						t
+					);
+				}
+				return (
+					n(t, e),
+					Object.defineProperty(t.prototype, "kind", {
+						get: function () {
+							return "proofTree";
+						},
+						enumerable: !1,
+						configurable: !0,
+					}),
+					(t.prototype.checkItem = function (e) {
+						if (e.isKind("end") && "prooftree" === e.getName()) {
+							var t = this.toMml();
+							return (
+								u.setProperty(t, "proof", !0),
+								[[this.factory.create("mml", t), e], !0]
+							);
+						}
+						if (e.isKind("stop"))
+							throw new a.default(
+								"EnvMissingEnd",
+								"Missing \\end{%1}",
+								this.getName(),
+							);
+						return this.innerStack.Push(e), i.BaseItem.fail;
+					}),
+					(t.prototype.toMml = function () {
+						var t = e.prototype.toMml.call(this),
+							r = this.innerStack.Top();
+						if (r.isKind("start") && !r.Size()) return t;
+						this.innerStack.Push(this.factory.create("stop"));
+						var o = this.innerStack.Top().toMml();
+						return this.create("node", "mrow", [o, t], {});
+					}),
+					t
+				);
+			})(i.BaseItem);
+		t.ProofTreeItem = f;
+	},
+	function (e, t, r) {
+		"use strict";
+		var o =
+				(this && this.__read) ||
+				function (e, t) {
+					var r = "function" == typeof Symbol && e[Symbol.iterator];
+					if (!r) return e;
+					var o,
+						n,
+						a = r.call(e),
+						i = [];
+					try {
+						for (; (void 0 === t || t-- > 0) && !(o = a.next()).done; )
+							i.push(o.value);
+					} catch (e) {
+						n = { error: e };
+					} finally {
+						try {
+							o && !o.done && (r = a.return) && r.call(a);
+						} finally {
+							if (n) throw n.error;
+						}
+					}
+					return i;
+				},
+			n =
+				(this && this.__spread) ||
+				function () {
+					for (var e = [], t = 0; t < arguments.length; t++)
+						e = e.concat(o(arguments[t]));
+					return e;
+				};
+		Object.defineProperty(t, "__esModule", { value: !0 });
+		var a = r(3),
+			i = r(12),
+			l = r(4),
+			u = r(0),
+			f = {
+				Prooftree: function (e, t) {
+					return (
+						e.Push(t),
+						e.itemFactory.create("proofTree").setProperties({
+							name: t.getName(),
+							line: "solid",
+							currentLine: "solid",
+							rootAtTop: !1,
+						})
+					);
+				},
+				Axiom: function (e, t) {
+					var r = e.stack.Top();
+					if ("proofTree" !== r.kind)
+						throw new a.default(
+							"IllegalProofCommand",
+							"Proof commands only allowed in prooftree environment.",
+						);
+					var o = s(e, e.GetArgument(t));
+					u.setProperty(o, "axiom", !0), r.Push(o);
+				},
+			},
+			s = function (e, t) {
+				var r = l.default.internalMath(e, l.default.trimSpaces(t), 0);
+				if (!r[0].childNodes[0].childNodes.length)
+					return e.create("node", "mrow", []);
+				var o = e.create("node", "mspace", [], { width: ".5ex" }),
+					a = e.create("node", "mspace", [], { width: ".5ex" });
+				return e.create("node", "mrow", n([o], r, [a]));
+			};
+		function c(e, t, r, o, n, a, i) {
+			var l,
+				f,
+				s,
+				c,
+				d = e.create("node", "mtr", [e.create("node", "mtd", [t], {})], {}),
+				p = e.create("node", "mtr", [e.create("node", "mtd", r, {})], {}),
+				m = e.create("node", "mtable", i ? [p, d] : [d, p], {
+					align: "top 2",
+					rowlines: a,
+					framespacing: "0 0",
+				});
+			if (
+				(u.setProperty(m, "inferenceRule", i ? "up" : "down"),
+				o &&
+					((l = e.create("node", "mpadded", [o], {
+						height: "+.5em",
+						width: "+.5em",
+						voffset: "-.15em",
+					})),
+					u.setProperty(l, "prooflabel", "left")),
+				n &&
+					((f = e.create("node", "mpadded", [n], {
+						height: "+.5em",
+						width: "+.5em",
+						voffset: "-.15em",
+					})),
+					u.setProperty(f, "prooflabel", "right")),
+				o && n)
+			)
+				(s = [l, m, f]), (c = "both");
+			else if (o) (s = [l, m]), (c = "left");
+			else {
+				if (!n) return m;
+				(s = [m, f]), (c = "right");
+			}
+			return (
+				(m = e.create("node", "mrow", s)),
+				u.setProperty(m, "labelledRule", c),
+				m
+			);
+		}
+		function d(e, t) {
+			if ("$" !== e.GetNext())
+				throw new a.default(
+					"IllegalUseOfCommand",
+					"Use of %1 does not match it's definition.",
+					t,
+				);
+			e.i++;
+			var r = e.GetUpTo(t, "$");
+			if (-1 === r.indexOf("\\fCenter"))
+				throw new a.default(
+					"IllegalUseOfCommand",
+					"Missing \\fCenter in %1.",
+					t,
+				);
+			var n = o(r.split("\\fCenter"), 2),
+				l = n[0],
+				f = n[1],
+				s = new i.default(l, e.stack.env, e.configuration).mml(),
+				c = new i.default(f, e.stack.env, e.configuration).mml(),
+				d = new i.default("\\fCenter", e.stack.env, e.configuration).mml(),
+				p = e.create("node", "mtd", [s], {}),
+				m = e.create("node", "mtd", [d], {}),
+				h = e.create("node", "mtd", [c], {}),
+				y = e.create("node", "mtr", [p, m, h], {}),
+				v = e.create("node", "mtable", [y], {
+					columnspacing: ".5ex",
+					columnalign: "center 2",
+				});
+			return (
+				u.setProperty(v, "sequent", !0),
+				e.configuration.addNode("sequent", y),
+				v
+			);
+		}
+		(f.Inference = function (e, t, r) {
+			var o = e.stack.Top();
+			if ("proofTree" !== o.kind)
+				throw new a.default(
+					"IllegalProofCommand",
+					"Proof commands only allowed in prooftree environment.",
+				);
+			if (o.Size() < r)
+				throw new a.default("BadProofTree", "Proof tree badly specified.");
+			var n = o.getProperty("rootAtTop"),
+				i = 1 !== r || o.Peek()[0].childNodes.length ? r : 0,
+				l = [];
+			do {
+				l.length && l.unshift(e.create("node", "mtd", [], {})),
+					l.unshift(
+						e.create("node", "mtd", [o.Pop()], {
+							rowalign: n ? "top" : "bottom",
+						}),
+					),
+					r--;
+			} while (r > 0);
+			var f = e.create("node", "mtr", l, {}),
+				d = e.create("node", "mtable", [f], { framespacing: "0 0" }),
+				p = s(e, e.GetArgument(t)),
+				m = o.getProperty("currentLine");
+			m !== o.getProperty("line") &&
+				o.setProperty("currentLine", o.getProperty("line"));
+			var h = c(e, d, [p], o.getProperty("left"), o.getProperty("right"), m, n);
+			o.setProperty("left", null),
+				o.setProperty("right", null),
+				u.setProperty(h, "inference", i),
+				e.configuration.addNode("inference", h),
+				o.Push(h);
+		}),
+			(f.Label = function (e, t, r) {
+				var o = e.stack.Top();
+				if ("proofTree" !== o.kind)
+					throw new a.default(
+						"IllegalProofCommand",
+						"Proof commands only allowed in prooftree environment.",
+					);
+				var n = l.default.internalMath(e, e.GetArgument(t), 0),
+					i = n.length > 1 ? e.create("node", "mrow", n, {}) : n[0];
+				o.setProperty(r, i);
+			}),
+			(f.SetLine = function (e, t, r, o) {
+				var n = e.stack.Top();
+				if ("proofTree" !== n.kind)
+					throw new a.default(
+						"IllegalProofCommand",
+						"Proof commands only allowed in prooftree environment.",
+					);
+				n.setProperty("currentLine", r), o && n.setProperty("line", r);
+			}),
+			(f.RootAtTop = function (e, t, r) {
+				var o = e.stack.Top();
+				if ("proofTree" !== o.kind)
+					throw new a.default(
+						"IllegalProofCommand",
+						"Proof commands only allowed in prooftree environment.",
+					);
+				o.setProperty("rootAtTop", r);
+			}),
+			(f.AxiomF = function (e, t) {
+				var r = e.stack.Top();
+				if ("proofTree" !== r.kind)
+					throw new a.default(
+						"IllegalProofCommand",
+						"Proof commands only allowed in prooftree environment.",
+					);
+				var o = d(e, t);
+				u.setProperty(o, "axiom", !0), r.Push(o);
+			}),
+			(f.FCenter = function (e, t) {}),
+			(f.InferenceF = function (e, t, r) {
+				var o = e.stack.Top();
+				if ("proofTree" !== o.kind)
+					throw new a.default(
+						"IllegalProofCommand",
+						"Proof commands only allowed in prooftree environment.",
+					);
+				if (o.Size() < r)
+					throw new a.default("BadProofTree", "Proof tree badly specified.");
+				var n = o.getProperty("rootAtTop"),
+					i = 1 !== r || o.Peek()[0].childNodes.length ? r : 0,
+					l = [];
+				do {
+					l.length && l.unshift(e.create("node", "mtd", [], {})),
+						l.unshift(
+							e.create("node", "mtd", [o.Pop()], {
+								rowalign: n ? "top" : "bottom",
+							}),
+						),
+						r--;
+				} while (r > 0);
+				var f = e.create("node", "mtr", l, {}),
+					s = e.create("node", "mtable", [f], { framespacing: "0 0" }),
+					p = d(e, t),
+					m = o.getProperty("currentLine");
+				m !== o.getProperty("line") &&
+					o.setProperty("currentLine", o.getProperty("line"));
+				var h = c(
+					e,
+					s,
+					[p],
+					o.getProperty("left"),
+					o.getProperty("right"),
+					m,
+					n,
+				);
+				o.setProperty("left", null),
+					o.setProperty("right", null),
+					u.setProperty(h, "inference", i),
+					e.configuration.addNode("inference", h),
+					o.Push(h);
+			}),
+			(t.default = f);
+	},
+	function (e, t, r) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.default = MathJax._.input.tex.TexError.default);
+	},
+	function (e, t, r) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.default = MathJax._.input.tex.ParseUtil.default);
+	},
+	function (e, t, r) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.isObject = MathJax._.components.global.isObject),
+			(t.combineConfig = MathJax._.components.global.combineConfig),
+			(t.combineDefaults = MathJax._.components.global.combineDefaults),
+			(t.combineWithMathJax = MathJax._.components.global.combineWithMathJax),
+			(t.MathJax = MathJax._.components.global.MathJax);
+	},
+	function (e, t, r) {
+		"use strict";
+		var o;
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.BussproofsConfiguration = void 0);
+		var n = r(7),
+			a = r(1),
+			i = r(0);
+		r(11),
+			(t.BussproofsConfiguration = n.Configuration.create("bussproofs", {
+				handler: {
+					macro: ["Bussproofs-macros"],
+					environment: ["Bussproofs-environments"],
+				},
+				items:
+					((o = {}), (o[a.ProofTreeItem.prototype.kind] = a.ProofTreeItem), o),
+				preprocessors: [[i.saveDocument, 1]],
+				postprocessors: [
+					[i.clearDocument, 3],
+					[i.makeBsprAttributes, 2],
+					[i.balanceRules, 1],
+				],
+			}));
+	},
+	function (e, t, r) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.Configuration = MathJax._.input.tex.Configuration.Configuration),
+			(t.ConfigurationHandler =
+				MathJax._.input.tex.Configuration.ConfigurationHandler),
+			(t.ParserConfiguration =
+				MathJax._.input.tex.Configuration.ParserConfiguration);
+	},
+	function (e, t, r) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.MmlStack = MathJax._.input.tex.StackItem.MmlStack),
+			(t.BaseItem = MathJax._.input.tex.StackItem.BaseItem);
+	},
+	function (e, t, r) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.default = MathJax._.input.tex.Stack.default);
+	},
+	function (e, t, r) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.default = MathJax._.input.tex.NodeUtil.default);
+	},
+	function (e, t, r) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 });
+		var o = r(2),
+			n = r(13),
+			a = r(14);
+		new a.CommandMap(
+			"Bussproofs-macros",
+			{
+				AxiomC: "Axiom",
+				UnaryInfC: ["Inference", 1],
+				BinaryInfC: ["Inference", 2],
+				TrinaryInfC: ["Inference", 3],
+				QuaternaryInfC: ["Inference", 4],
+				QuinaryInfC: ["Inference", 5],
+				RightLabel: ["Label", "right"],
+				LeftLabel: ["Label", "left"],
+				AXC: "Axiom",
+				UIC: ["Inference", 1],
+				BIC: ["Inference", 2],
+				TIC: ["Inference", 3],
+				RL: ["Label", "right"],
+				LL: ["Label", "left"],
+				noLine: ["SetLine", "none", !1],
+				singleLine: ["SetLine", "solid", !1],
+				solidLine: ["SetLine", "solid", !1],
+				dashedLine: ["SetLine", "dashed", !1],
+				alwaysNoLine: ["SetLine", "none", !0],
+				alwaysSingleLine: ["SetLine", "solid", !0],
+				alwaysSolidLine: ["SetLine", "solid", !0],
+				alwaysDashedLine: ["SetLine", "dashed", !0],
+				rootAtTop: ["RootAtTop", !0],
+				alwaysRootAtTop: ["RootAtTop", !0],
+				rootAtBottom: ["RootAtTop", !1],
+				alwaysRootAtBottom: ["RootAtTop", !1],
+				fCenter: "FCenter",
+				Axiom: "AxiomF",
+				UnaryInf: ["InferenceF", 1],
+				BinaryInf: ["InferenceF", 2],
+				TrinaryInf: ["InferenceF", 3],
+				QuaternaryInf: ["InferenceF", 4],
+				QuinaryInf: ["InferenceF", 5],
+			},
+			o.default,
+		),
+			new a.EnvironmentMap(
+				"Bussproofs-environments",
+				n.default.environment,
+				{ prooftree: ["Prooftree", null, !1] },
+				o.default,
+			);
+	},
+	function (e, t, r) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.default = MathJax._.input.tex.TexParser.default);
+	},
+	function (e, t, r) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.default = MathJax._.input.tex.ParseMethods.default);
+	},
+	function (e, t, r) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.AbstractSymbolMap = MathJax._.input.tex.SymbolMap.AbstractSymbolMap),
+			(t.RegExpMap = MathJax._.input.tex.SymbolMap.RegExpMap),
+			(t.AbstractParseMap = MathJax._.input.tex.SymbolMap.AbstractParseMap),
+			(t.CharacterMap = MathJax._.input.tex.SymbolMap.CharacterMap),
+			(t.DelimiterMap = MathJax._.input.tex.SymbolMap.DelimiterMap),
+			(t.MacroMap = MathJax._.input.tex.SymbolMap.MacroMap),
+			(t.CommandMap = MathJax._.input.tex.SymbolMap.CommandMap),
+			(t.EnvironmentMap = MathJax._.input.tex.SymbolMap.EnvironmentMap);
+	},
+	function (e, t, r) {
+		"use strict";
+		r.r(t);
+		var o = r(5),
+			n = r(6),
+			a = r(1),
+			i = r(2),
+			l = r(0);
+		Object(o.combineWithMathJax)({
+			_: {
+				input: {
+					tex: {
+						bussproofs: {
+							BussproofsConfiguration: n,
+							BussproofsItems: a,
+							BussproofsMethods: i,
+							BussproofsUtil: l,
+						},
+					},
+				},
+			},
+		});
+	},
+]);

assets/bower_components/MathJax/es5/input/tex/extensions/cancel.js

@@ -0,0 +1,168 @@
+!(function (e) {
+	var t = {};
+	function n(a) {
+		if (t[a]) return t[a].exports;
+		var o = (t[a] = { i: a, l: !1, exports: {} });
+		return e[a].call(o.exports, o, o.exports, n), (o.l = !0), o.exports;
+	}
+	(n.m = e),
+		(n.c = t),
+		(n.d = function (e, t, a) {
+			n.o(e, t) || Object.defineProperty(e, t, { enumerable: !0, get: a });
+		}),
+		(n.r = function (e) {
+			"undefined" != typeof Symbol &&
+				Symbol.toStringTag &&
+				Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }),
+				Object.defineProperty(e, "__esModule", { value: !0 });
+		}),
+		(n.t = function (e, t) {
+			if ((1 & t && (e = n(e)), 8 & t)) return e;
+			if (4 & t && "object" == typeof e && e && e.__esModule) return e;
+			var a = Object.create(null);
+			if (
+				(n.r(a),
+				Object.defineProperty(a, "default", { enumerable: !0, value: e }),
+				2 & t && "string" != typeof e)
+			)
+				for (var o in e)
+					n.d(
+						a,
+						o,
+						function (t) {
+							return e[t];
+						}.bind(null, o),
+					);
+			return a;
+		}),
+		(n.n = function (e) {
+			var t =
+				e && e.__esModule
+					? function () {
+							return e.default;
+						}
+					: function () {
+							return e;
+						};
+			return n.d(t, "a", t), t;
+		}),
+		(n.o = function (e, t) {
+			return Object.prototype.hasOwnProperty.call(e, t);
+		}),
+		(n.p = ""),
+		n((n.s = 7));
+})([
+	function (e, t, n) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.isObject = MathJax._.components.global.isObject),
+			(t.combineConfig = MathJax._.components.global.combineConfig),
+			(t.combineDefaults = MathJax._.components.global.combineDefaults),
+			(t.combineWithMathJax = MathJax._.components.global.combineWithMathJax),
+			(t.MathJax = MathJax._.components.global.MathJax);
+	},
+	function (e, t, n) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.CancelConfiguration = t.CancelMethods = void 0);
+		var a = n(2),
+			o = n(3),
+			i = n(4),
+			r = n(5),
+			c = n(6);
+		(t.CancelMethods = {}),
+			(t.CancelMethods.Cancel = function (e, t, n) {
+				var a = e.GetBrackets(t, ""),
+					o = e.ParseArg(t),
+					i = r.default.keyvalOptions(a, c.ENCLOSE_OPTIONS);
+				(i.notation = n), e.Push(e.create("node", "menclose", [o], i));
+			}),
+			(t.CancelMethods.CancelTo = function (e, t) {
+				var n = e.GetBrackets(t, ""),
+					a = e.ParseArg(t),
+					i = e.ParseArg(t),
+					u = r.default.keyvalOptions(n, c.ENCLOSE_OPTIONS);
+				(u.notation = [
+					o.TexConstant.Notation.UPDIAGONALSTRIKE,
+					o.TexConstant.Notation.UPDIAGONALARROW,
+					o.TexConstant.Notation.NORTHEASTARROW,
+				].join(" ")),
+					(a = e.create("node", "mpadded", [a], {
+						depth: "-.1em",
+						height: "+.1em",
+						voffset: ".1em",
+					})),
+					e.Push(
+						e.create("node", "msup", [e.create("node", "menclose", [i], u), a]),
+					);
+			}),
+			new i.CommandMap(
+				"cancel",
+				{
+					cancel: ["Cancel", o.TexConstant.Notation.UPDIAGONALSTRIKE],
+					bcancel: ["Cancel", o.TexConstant.Notation.DOWNDIAGONALSTRIKE],
+					xcancel: [
+						"Cancel",
+						o.TexConstant.Notation.UPDIAGONALSTRIKE +
+							" " +
+							o.TexConstant.Notation.DOWNDIAGONALSTRIKE,
+					],
+					cancelto: "CancelTo",
+				},
+				t.CancelMethods,
+			),
+			(t.CancelConfiguration = a.Configuration.create("cancel", {
+				handler: { macro: ["cancel"] },
+			}));
+	},
+	function (e, t, n) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.Configuration = MathJax._.input.tex.Configuration.Configuration),
+			(t.ConfigurationHandler =
+				MathJax._.input.tex.Configuration.ConfigurationHandler),
+			(t.ParserConfiguration =
+				MathJax._.input.tex.Configuration.ParserConfiguration);
+	},
+	function (e, t, n) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.TexConstant = MathJax._.input.tex.TexConstants.TexConstant);
+	},
+	function (e, t, n) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.AbstractSymbolMap = MathJax._.input.tex.SymbolMap.AbstractSymbolMap),
+			(t.RegExpMap = MathJax._.input.tex.SymbolMap.RegExpMap),
+			(t.AbstractParseMap = MathJax._.input.tex.SymbolMap.AbstractParseMap),
+			(t.CharacterMap = MathJax._.input.tex.SymbolMap.CharacterMap),
+			(t.DelimiterMap = MathJax._.input.tex.SymbolMap.DelimiterMap),
+			(t.MacroMap = MathJax._.input.tex.SymbolMap.MacroMap),
+			(t.CommandMap = MathJax._.input.tex.SymbolMap.CommandMap),
+			(t.EnvironmentMap = MathJax._.input.tex.SymbolMap.EnvironmentMap);
+	},
+	function (e, t, n) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.default = MathJax._.input.tex.ParseUtil.default);
+	},
+	function (e, t, n) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.ENCLOSE_OPTIONS =
+				MathJax._.input.tex.enclose.EncloseConfiguration.ENCLOSE_OPTIONS),
+			(t.EncloseMethods =
+				MathJax._.input.tex.enclose.EncloseConfiguration.EncloseMethods),
+			(t.EncloseConfiguration =
+				MathJax._.input.tex.enclose.EncloseConfiguration.EncloseConfiguration);
+	},
+	function (e, t, n) {
+		"use strict";
+		n.r(t);
+		var a = n(0),
+			o = n(1);
+		Object(a.combineWithMathJax)({
+			_: { input: { tex: { cancel: { CancelConfiguration: o } } } },
+		});
+	},
+]);

assets/bower_components/MathJax/es5/input/tex/extensions/color.js

@@ -0,0 +1,449 @@
+!(function (e) {
+	var o = {};
+	function t(r) {
+		if (o[r]) return o[r].exports;
+		var n = (o[r] = { i: r, l: !1, exports: {} });
+		return e[r].call(n.exports, n, n.exports, t), (n.l = !0), n.exports;
+	}
+	(t.m = e),
+		(t.c = o),
+		(t.d = function (e, o, r) {
+			t.o(e, o) || Object.defineProperty(e, o, { enumerable: !0, get: r });
+		}),
+		(t.r = function (e) {
+			"undefined" != typeof Symbol &&
+				Symbol.toStringTag &&
+				Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }),
+				Object.defineProperty(e, "__esModule", { value: !0 });
+		}),
+		(t.t = function (e, o) {
+			if ((1 & o && (e = t(e)), 8 & o)) return e;
+			if (4 & o && "object" == typeof e && e && e.__esModule) return e;
+			var r = Object.create(null);
+			if (
+				(t.r(r),
+				Object.defineProperty(r, "default", { enumerable: !0, value: e }),
+				2 & o && "string" != typeof e)
+			)
+				for (var n in e)
+					t.d(
+						r,
+						n,
+						function (o) {
+							return e[o];
+						}.bind(null, n),
+					);
+			return r;
+		}),
+		(t.n = function (e) {
+			var o =
+				e && e.__esModule
+					? function () {
+							return e.default;
+						}
+					: function () {
+							return e;
+						};
+			return t.d(o, "a", o), o;
+		}),
+		(t.o = function (e, o) {
+			return Object.prototype.hasOwnProperty.call(e, o);
+		}),
+		(t.p = ""),
+		t((t.s = 10));
+})([
+	function (e, o, t) {
+		"use strict";
+		Object.defineProperty(o, "__esModule", { value: !0 }),
+			(o.ColorMethods = void 0);
+		var r = t(7),
+			n = t(8);
+		function a(e) {
+			var o = "+" + e,
+				t = e.replace(/^.*?([a-z]*)$/, "$1");
+			return {
+				width: "+" + 2 * parseFloat(o) + t,
+				height: o,
+				depth: o,
+				lspace: e,
+			};
+		}
+		(o.ColorMethods = {}),
+			(o.ColorMethods.Color = function (e, o) {
+				var t = e.GetBrackets(o, ""),
+					r = e.GetArgument(o),
+					n = e.configuration.packageData.get("color").model.getColor(t, r),
+					a = e.itemFactory
+						.create("style")
+						.setProperties({ styles: { mathcolor: n } });
+				(e.stack.env.color = n), e.Push(a);
+			}),
+			(o.ColorMethods.TextColor = function (e, o) {
+				var t = e.GetBrackets(o, ""),
+					r = e.GetArgument(o),
+					n = e.configuration.packageData.get("color").model.getColor(t, r),
+					a = e.stack.env.color;
+				e.stack.env.color = n;
+				var l = e.ParseArg(o);
+				a ? (e.stack.env.color = a) : delete e.stack.env.color;
+				var i = e.create("node", "mstyle", [l], { mathcolor: n });
+				e.Push(i);
+			}),
+			(o.ColorMethods.DefineColor = function (e, o) {
+				var t = e.GetArgument(o),
+					r = e.GetArgument(o),
+					n = e.GetArgument(o);
+				e.configuration.packageData.get("color").model.defineColor(r, t, n);
+			}),
+			(o.ColorMethods.ColorBox = function (e, o) {
+				var t = e.GetArgument(o),
+					l = n.default.internalMath(e, e.GetArgument(o)),
+					i = e.configuration.packageData.get("color").model,
+					u = e.create("node", "mpadded", l, {
+						mathbackground: i.getColor("named", t),
+					});
+				r.default.setProperties(u, a(e.options.color.padding)), e.Push(u);
+			}),
+			(o.ColorMethods.FColorBox = function (e, o) {
+				var t = e.GetArgument(o),
+					l = e.GetArgument(o),
+					i = n.default.internalMath(e, e.GetArgument(o)),
+					u = e.options.color,
+					d = e.configuration.packageData.get("color").model,
+					c = e.create("node", "mpadded", i, {
+						mathbackground: d.getColor("named", l),
+						style:
+							"border: " + u.borderWidth + " solid " + d.getColor("named", t),
+					});
+				r.default.setProperties(c, a(u.padding)), e.Push(c);
+			});
+	},
+	function (e, o, t) {
+		"use strict";
+		var r =
+			(this && this.__values) ||
+			function (e) {
+				var o = "function" == typeof Symbol && Symbol.iterator,
+					t = o && e[o],
+					r = 0;
+				if (t) return t.call(e);
+				if (e && "number" == typeof e.length)
+					return {
+						next: function () {
+							return (
+								e && r >= e.length && (e = void 0),
+								{ value: e && e[r++], done: !e }
+							);
+						},
+					};
+				throw new TypeError(
+					o ? "Object is not iterable." : "Symbol.iterator is not defined.",
+				);
+			};
+		Object.defineProperty(o, "__esModule", { value: !0 }),
+			(o.ColorModel = void 0);
+		var n = t(9),
+			a = t(2),
+			l = new Map(),
+			i = (function () {
+				function e() {
+					this.userColors = new Map();
+				}
+				return (
+					(e.prototype.normalizeColor = function (e, o) {
+						if (!e || "named" === e) return o;
+						if (l.has(e)) return l.get(e)(o);
+						throw new n.default(
+							"UndefinedColorModel",
+							"Color model '%1' not defined",
+							e,
+						);
+					}),
+					(e.prototype.getColor = function (e, o) {
+						return e && "named" !== e
+							? this.normalizeColor(e, o)
+							: this.getColorByName(o);
+					}),
+					(e.prototype.getColorByName = function (e) {
+						return this.userColors.has(e)
+							? this.userColors.get(e)
+							: a.COLORS.has(e)
+								? a.COLORS.get(e)
+								: e;
+					}),
+					(e.prototype.defineColor = function (e, o, t) {
+						var r = this.normalizeColor(e, t);
+						this.userColors.set(o, r);
+					}),
+					e
+				);
+			})();
+		(o.ColorModel = i),
+			l.set("rgb", function (e) {
+				var o,
+					t,
+					a = e.trim().split(/\s*,\s*/),
+					l = "#";
+				if (3 !== a.length)
+					throw new n.default(
+						"ModelArg1",
+						"Color values for the %1 model require 3 numbers",
+						"rgb",
+					);
+				try {
+					for (var i = r(a), u = i.next(); !u.done; u = i.next()) {
+						var d = u.value;
+						if (!d.match(/^(\d+(\.\d*)?|\.\d+)$/))
+							throw new n.default(
+								"InvalidDecimalNumber",
+								"Invalid decimal number",
+							);
+						var c = parseFloat(d);
+						if (c < 0 || c > 1)
+							throw new n.default(
+								"ModelArg2",
+								"Color values for the %1 model must be between %2 and %3",
+								"rgb",
+								"0",
+								"1",
+							);
+						var s = Math.floor(255 * c).toString(16);
+						s.length < 2 && (s = "0" + s), (l += s);
+					}
+				} catch (e) {
+					o = { error: e };
+				} finally {
+					try {
+						u && !u.done && (t = i.return) && t.call(i);
+					} finally {
+						if (o) throw o.error;
+					}
+				}
+				return l;
+			}),
+			l.set("RGB", function (e) {
+				var o,
+					t,
+					a = e.trim().split(/\s*,\s*/),
+					l = "#";
+				if (3 !== a.length)
+					throw new n.default(
+						"ModelArg1",
+						"Color values for the %1 model require 3 numbers",
+						"RGB",
+					);
+				try {
+					for (var i = r(a), u = i.next(); !u.done; u = i.next()) {
+						var d = u.value;
+						if (!d.match(/^\d+$/))
+							throw new n.default("InvalidNumber", "Invalid number");
+						var c = parseInt(d);
+						if (c > 255)
+							throw new n.default(
+								"ModelArg2",
+								"Color values for the %1 model must be between %2 and %3",
+								"RGB",
+								"0",
+								"255",
+							);
+						var s = c.toString(16);
+						s.length < 2 && (s = "0" + s), (l += s);
+					}
+				} catch (e) {
+					o = { error: e };
+				} finally {
+					try {
+						u && !u.done && (t = i.return) && t.call(i);
+					} finally {
+						if (o) throw o.error;
+					}
+				}
+				return l;
+			}),
+			l.set("gray", function (e) {
+				if (!e.match(/^\s*(\d+(\.\d*)?|\.\d+)\s*$/))
+					throw new n.default("InvalidDecimalNumber", "Invalid decimal number");
+				var o = parseFloat(e);
+				if (o < 0 || o > 1)
+					throw new n.default(
+						"ModelArg2",
+						"Color values for the %1 model must be between %2 and %3",
+						"gray",
+						"0",
+						"1",
+					);
+				var t = Math.floor(255 * o).toString(16);
+				return t.length < 2 && (t = "0" + t), "#" + t + t + t;
+			});
+	},
+	function (e, o, t) {
+		"use strict";
+		Object.defineProperty(o, "__esModule", { value: !0 }),
+			(o.COLORS = void 0),
+			(o.COLORS = new Map([
+				["Apricot", "#FBB982"],
+				["Aquamarine", "#00B5BE"],
+				["Bittersweet", "#C04F17"],
+				["Black", "#221E1F"],
+				["Blue", "#2D2F92"],
+				["BlueGreen", "#00B3B8"],
+				["BlueViolet", "#473992"],
+				["BrickRed", "#B6321C"],
+				["Brown", "#792500"],
+				["BurntOrange", "#F7921D"],
+				["CadetBlue", "#74729A"],
+				["CarnationPink", "#F282B4"],
+				["Cerulean", "#00A2E3"],
+				["CornflowerBlue", "#41B0E4"],
+				["Cyan", "#00AEEF"],
+				["Dandelion", "#FDBC42"],
+				["DarkOrchid", "#A4538A"],
+				["Emerald", "#00A99D"],
+				["ForestGreen", "#009B55"],
+				["Fuchsia", "#8C368C"],
+				["Goldenrod", "#FFDF42"],
+				["Gray", "#949698"],
+				["Green", "#00A64F"],
+				["GreenYellow", "#DFE674"],
+				["JungleGreen", "#00A99A"],
+				["Lavender", "#F49EC4"],
+				["LimeGreen", "#8DC73E"],
+				["Magenta", "#EC008C"],
+				["Mahogany", "#A9341F"],
+				["Maroon", "#AF3235"],
+				["Melon", "#F89E7B"],
+				["MidnightBlue", "#006795"],
+				["Mulberry", "#A93C93"],
+				["NavyBlue", "#006EB8"],
+				["OliveGreen", "#3C8031"],
+				["Orange", "#F58137"],
+				["OrangeRed", "#ED135A"],
+				["Orchid", "#AF72B0"],
+				["Peach", "#F7965A"],
+				["Periwinkle", "#7977B8"],
+				["PineGreen", "#008B72"],
+				["Plum", "#92268F"],
+				["ProcessBlue", "#00B0F0"],
+				["Purple", "#99479B"],
+				["RawSienna", "#974006"],
+				["Red", "#ED1B23"],
+				["RedOrange", "#F26035"],
+				["RedViolet", "#A1246B"],
+				["Rhodamine", "#EF559F"],
+				["RoyalBlue", "#0071BC"],
+				["RoyalPurple", "#613F99"],
+				["RubineRed", "#ED017D"],
+				["Salmon", "#F69289"],
+				["SeaGreen", "#3FBC9D"],
+				["Sepia", "#671800"],
+				["SkyBlue", "#46C5DD"],
+				["SpringGreen", "#C6DC67"],
+				["Tan", "#DA9D76"],
+				["TealBlue", "#00AEB3"],
+				["Thistle", "#D883B7"],
+				["Turquoise", "#00B4CE"],
+				["Violet", "#58429B"],
+				["VioletRed", "#EF58A0"],
+				["White", "#FFFFFF"],
+				["WildStrawberry", "#EE2967"],
+				["Yellow", "#FFF200"],
+				["YellowGreen", "#98CC70"],
+				["YellowOrange", "#FAA21A"],
+			]));
+	},
+	function (e, o, t) {
+		"use strict";
+		Object.defineProperty(o, "__esModule", { value: !0 }),
+			(o.isObject = MathJax._.components.global.isObject),
+			(o.combineConfig = MathJax._.components.global.combineConfig),
+			(o.combineDefaults = MathJax._.components.global.combineDefaults),
+			(o.combineWithMathJax = MathJax._.components.global.combineWithMathJax),
+			(o.MathJax = MathJax._.components.global.MathJax);
+	},
+	function (e, o, t) {
+		"use strict";
+		Object.defineProperty(o, "__esModule", { value: !0 }),
+			(o.ColorConfiguration = void 0);
+		var r = t(5),
+			n = t(6),
+			a = t(0),
+			l = t(1);
+		new r.CommandMap(
+			"color",
+			{
+				color: "Color",
+				textcolor: "TextColor",
+				definecolor: "DefineColor",
+				colorbox: "ColorBox",
+				fcolorbox: "FColorBox",
+			},
+			a.ColorMethods,
+		);
+		o.ColorConfiguration = n.Configuration.create("color", {
+			handler: { macro: ["color"] },
+			options: { color: { padding: "5px", borderWidth: "2px" } },
+			config: function (e, o) {
+				o.parseOptions.packageData.set("color", { model: new l.ColorModel() });
+			},
+		});
+	},
+	function (e, o, t) {
+		"use strict";
+		Object.defineProperty(o, "__esModule", { value: !0 }),
+			(o.AbstractSymbolMap = MathJax._.input.tex.SymbolMap.AbstractSymbolMap),
+			(o.RegExpMap = MathJax._.input.tex.SymbolMap.RegExpMap),
+			(o.AbstractParseMap = MathJax._.input.tex.SymbolMap.AbstractParseMap),
+			(o.CharacterMap = MathJax._.input.tex.SymbolMap.CharacterMap),
+			(o.DelimiterMap = MathJax._.input.tex.SymbolMap.DelimiterMap),
+			(o.MacroMap = MathJax._.input.tex.SymbolMap.MacroMap),
+			(o.CommandMap = MathJax._.input.tex.SymbolMap.CommandMap),
+			(o.EnvironmentMap = MathJax._.input.tex.SymbolMap.EnvironmentMap);
+	},
+	function (e, o, t) {
+		"use strict";
+		Object.defineProperty(o, "__esModule", { value: !0 }),
+			(o.Configuration = MathJax._.input.tex.Configuration.Configuration),
+			(o.ConfigurationHandler =
+				MathJax._.input.tex.Configuration.ConfigurationHandler),
+			(o.ParserConfiguration =
+				MathJax._.input.tex.Configuration.ParserConfiguration);
+	},
+	function (e, o, t) {
+		"use strict";
+		Object.defineProperty(o, "__esModule", { value: !0 }),
+			(o.default = MathJax._.input.tex.NodeUtil.default);
+	},
+	function (e, o, t) {
+		"use strict";
+		Object.defineProperty(o, "__esModule", { value: !0 }),
+			(o.default = MathJax._.input.tex.ParseUtil.default);
+	},
+	function (e, o, t) {
+		"use strict";
+		Object.defineProperty(o, "__esModule", { value: !0 }),
+			(o.default = MathJax._.input.tex.TexError.default);
+	},
+	function (e, o, t) {
+		"use strict";
+		t.r(o);
+		var r = t(3),
+			n = t(4),
+			a = t(2),
+			l = t(0),
+			i = t(1);
+		Object(r.combineWithMathJax)({
+			_: {
+				input: {
+					tex: {
+						color: {
+							ColorConfiguration: n,
+							ColorConstants: a,
+							ColorMethods: l,
+							ColorUtil: i,
+						},
+					},
+				},
+			},
+		});
+	},
+]);

assets/bower_components/MathJax/es5/input/tex/extensions/colorV2.js

@@ -0,0 +1,145 @@
+!(function (t) {
+	var e = {};
+	function o(a) {
+		if (e[a]) return e[a].exports;
+		var n = (e[a] = { i: a, l: !1, exports: {} });
+		return t[a].call(n.exports, n, n.exports, o), (n.l = !0), n.exports;
+	}
+	(o.m = t),
+		(o.c = e),
+		(o.d = function (t, e, a) {
+			o.o(t, e) || Object.defineProperty(t, e, { enumerable: !0, get: a });
+		}),
+		(o.r = function (t) {
+			"undefined" != typeof Symbol &&
+				Symbol.toStringTag &&
+				Object.defineProperty(t, Symbol.toStringTag, { value: "Module" }),
+				Object.defineProperty(t, "__esModule", { value: !0 });
+		}),
+		(o.t = function (t, e) {
+			if ((1 & e && (t = o(t)), 8 & e)) return t;
+			if (4 & e && "object" == typeof t && t && t.__esModule) return t;
+			var a = Object.create(null);
+			if (
+				(o.r(a),
+				Object.defineProperty(a, "default", { enumerable: !0, value: t }),
+				2 & e && "string" != typeof t)
+			)
+				for (var n in t)
+					o.d(
+						a,
+						n,
+						function (e) {
+							return t[e];
+						}.bind(null, n),
+					);
+			return a;
+		}),
+		(o.n = function (t) {
+			var e =
+				t && t.__esModule
+					? function () {
+							return t.default;
+						}
+					: function () {
+							return t;
+						};
+			return o.d(e, "a", e), e;
+		}),
+		(o.o = function (t, e) {
+			return Object.prototype.hasOwnProperty.call(t, e);
+		}),
+		(o.p = ""),
+		o((o.s = 4));
+})([
+	function (t, e, o) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.isObject = MathJax._.components.global.isObject),
+			(e.combineConfig = MathJax._.components.global.combineConfig),
+			(e.combineDefaults = MathJax._.components.global.combineDefaults),
+			(e.combineWithMathJax = MathJax._.components.global.combineWithMathJax),
+			(e.MathJax = MathJax._.components.global.MathJax);
+	},
+	function (t, e, o) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.ColorConfiguration = e.ColorV2Methods = void 0);
+		var a = o(2),
+			n = o(3);
+		(e.ColorV2Methods = {
+			Color: function (t, e) {
+				var o = t.GetArgument(e),
+					a = t.stack.env.color;
+				t.stack.env.color = o;
+				var n = t.ParseArg(e);
+				a ? (t.stack.env.color = a) : delete t.stack.env.color;
+				var r = t.create("node", "mstyle", [n], { mathcolor: o });
+				t.Push(r);
+			},
+		}),
+			new a.CommandMap("colorv2", { color: "Color" }, e.ColorV2Methods),
+			(e.ColorConfiguration = n.Configuration.create("colorv2", {
+				handler: { macro: ["colorv2"] },
+			}));
+	},
+	function (t, e, o) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.AbstractSymbolMap = MathJax._.input.tex.SymbolMap.AbstractSymbolMap),
+			(e.RegExpMap = MathJax._.input.tex.SymbolMap.RegExpMap),
+			(e.AbstractParseMap = MathJax._.input.tex.SymbolMap.AbstractParseMap),
+			(e.CharacterMap = MathJax._.input.tex.SymbolMap.CharacterMap),
+			(e.DelimiterMap = MathJax._.input.tex.SymbolMap.DelimiterMap),
+			(e.MacroMap = MathJax._.input.tex.SymbolMap.MacroMap),
+			(e.CommandMap = MathJax._.input.tex.SymbolMap.CommandMap),
+			(e.EnvironmentMap = MathJax._.input.tex.SymbolMap.EnvironmentMap);
+	},
+	function (t, e, o) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.Configuration = MathJax._.input.tex.Configuration.Configuration),
+			(e.ConfigurationHandler =
+				MathJax._.input.tex.Configuration.ConfigurationHandler),
+			(e.ParserConfiguration =
+				MathJax._.input.tex.Configuration.ParserConfiguration);
+	},
+	function (t, e, o) {
+		"use strict";
+		o.r(e);
+		var a = o(0),
+			n = o(1);
+		Object(a.combineWithMathJax)({
+			_: { input: { tex: { colorv2: { ColorV2Configuration: n } } } },
+		}),
+			(function (t, e, o) {
+				var n,
+					r,
+					i,
+					c = MathJax.config.tex;
+				if (c && c.packages) {
+					var l = c.packages,
+						u = l.indexOf(t);
+					u >= 0 && (l[u] = e),
+						o &&
+							c[t] &&
+							(Object(a.combineConfig)(
+								c,
+								((n = {}),
+								(r = e),
+								(i = c[t]),
+								r in n
+									? Object.defineProperty(n, r, {
+											value: i,
+											enumerable: !0,
+											configurable: !0,
+											writable: !0,
+										})
+									: (n[r] = i),
+								n),
+							),
+							delete c[t]);
+				}
+			})("colorV2", "colorv2", !1);
+	},
+]);

assets/bower_components/MathJax/es5/input/tex/extensions/configMacros.js

@@ -0,0 +1,221 @@
+!(function (t) {
+	var e = {};
+	function a(n) {
+		if (e[n]) return e[n].exports;
+		var o = (e[n] = { i: n, l: !1, exports: {} });
+		return t[n].call(o.exports, o, o.exports, a), (o.l = !0), o.exports;
+	}
+	(a.m = t),
+		(a.c = e),
+		(a.d = function (t, e, n) {
+			a.o(t, e) || Object.defineProperty(t, e, { enumerable: !0, get: n });
+		}),
+		(a.r = function (t) {
+			"undefined" != typeof Symbol &&
+				Symbol.toStringTag &&
+				Object.defineProperty(t, Symbol.toStringTag, { value: "Module" }),
+				Object.defineProperty(t, "__esModule", { value: !0 });
+		}),
+		(a.t = function (t, e) {
+			if ((1 & e && (t = a(t)), 8 & e)) return t;
+			if (4 & e && "object" == typeof t && t && t.__esModule) return t;
+			var n = Object.create(null);
+			if (
+				(a.r(n),
+				Object.defineProperty(n, "default", { enumerable: !0, value: t }),
+				2 & e && "string" != typeof t)
+			)
+				for (var o in t)
+					a.d(
+						n,
+						o,
+						function (e) {
+							return t[e];
+						}.bind(null, o),
+					);
+			return n;
+		}),
+		(a.n = function (t) {
+			var e =
+				t && t.__esModule
+					? function () {
+							return t.default;
+						}
+					: function () {
+							return t;
+						};
+			return a.d(e, "a", e), e;
+		}),
+		(a.o = function (t, e) {
+			return Object.prototype.hasOwnProperty.call(t, e);
+		}),
+		(a.p = ""),
+		a((a.s = 7));
+})([
+	function (t, e, a) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.isObject = MathJax._.components.global.isObject),
+			(e.combineConfig = MathJax._.components.global.combineConfig),
+			(e.combineDefaults = MathJax._.components.global.combineDefaults),
+			(e.combineWithMathJax = MathJax._.components.global.combineWithMathJax),
+			(e.MathJax = MathJax._.components.global.MathJax);
+	},
+	function (t, e, a) {
+		"use strict";
+		var n =
+			(this && this.__values) ||
+			function (t) {
+				var e = "function" == typeof Symbol && Symbol.iterator,
+					a = e && t[e],
+					n = 0;
+				if (a) return a.call(t);
+				if (t && "number" == typeof t.length)
+					return {
+						next: function () {
+							return (
+								t && n >= t.length && (t = void 0),
+								{ value: t && t[n++], done: !t }
+							);
+						},
+					};
+				throw new TypeError(
+					e ? "Object is not iterable." : "Symbol.iterator is not defined.",
+				);
+			};
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.ConfigMacrosConfiguration = void 0);
+		var o = a(2),
+			i = a(3),
+			r = a(4),
+			u = a(5),
+			c = a(6);
+		e.ConfigMacrosConfiguration = o.Configuration.create("configmacros", {
+			init: function (t) {
+				new r.CommandMap("configmacros-map", {}, {}),
+					t.append(
+						o.Configuration.local({
+							handler: { macro: ["configmacros-map"] },
+							priority: 3,
+						}),
+					);
+			},
+			config: function (t, e) {
+				var a,
+					o,
+					i = e.parseOptions.handlers.retrieve("configmacros-map"),
+					r = e.parseOptions.options.macros;
+				try {
+					for (var l = n(Object.keys(r)), p = l.next(); !p.done; p = l.next()) {
+						var s = p.value,
+							f = "string" == typeof r[s] ? [r[s]] : r[s],
+							M = Array.isArray(f[2])
+								? new u.Macro(
+										s,
+										c.default.MacroWithTemplate,
+										f.slice(0, 2).concat(f[2]),
+									)
+								: new u.Macro(s, c.default.Macro, f);
+						i.add(s, M);
+					}
+				} catch (t) {
+					a = { error: t };
+				} finally {
+					try {
+						p && !p.done && (o = l.return) && o.call(l);
+					} finally {
+						if (a) throw a.error;
+					}
+				}
+			},
+			options: { macros: i.expandable({}) },
+		});
+	},
+	function (t, e, a) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.Configuration = MathJax._.input.tex.Configuration.Configuration),
+			(e.ConfigurationHandler =
+				MathJax._.input.tex.Configuration.ConfigurationHandler),
+			(e.ParserConfiguration =
+				MathJax._.input.tex.Configuration.ParserConfiguration);
+	},
+	function (t, e, a) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.APPEND = MathJax._.util.Options.APPEND),
+			(e.REMOVE = MathJax._.util.Options.REMOVE),
+			(e.Expandable = MathJax._.util.Options.Expandable),
+			(e.expandable = MathJax._.util.Options.expandable),
+			(e.makeArray = MathJax._.util.Options.makeArray),
+			(e.keys = MathJax._.util.Options.keys),
+			(e.copy = MathJax._.util.Options.copy),
+			(e.insert = MathJax._.util.Options.insert),
+			(e.defaultOptions = MathJax._.util.Options.defaultOptions),
+			(e.userOptions = MathJax._.util.Options.userOptions),
+			(e.selectOptions = MathJax._.util.Options.selectOptions),
+			(e.selectOptionsFromKeys = MathJax._.util.Options.selectOptionsFromKeys),
+			(e.separateOptions = MathJax._.util.Options.separateOptions);
+	},
+	function (t, e, a) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.AbstractSymbolMap = MathJax._.input.tex.SymbolMap.AbstractSymbolMap),
+			(e.RegExpMap = MathJax._.input.tex.SymbolMap.RegExpMap),
+			(e.AbstractParseMap = MathJax._.input.tex.SymbolMap.AbstractParseMap),
+			(e.CharacterMap = MathJax._.input.tex.SymbolMap.CharacterMap),
+			(e.DelimiterMap = MathJax._.input.tex.SymbolMap.DelimiterMap),
+			(e.MacroMap = MathJax._.input.tex.SymbolMap.MacroMap),
+			(e.CommandMap = MathJax._.input.tex.SymbolMap.CommandMap),
+			(e.EnvironmentMap = MathJax._.input.tex.SymbolMap.EnvironmentMap);
+	},
+	function (t, e, a) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.Symbol = MathJax._.input.tex.Symbol.Symbol),
+			(e.Macro = MathJax._.input.tex.Symbol.Macro);
+	},
+	function (t, e, a) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.default = MathJax._.input.tex.newcommand.NewcommandMethods.default);
+	},
+	function (t, e, a) {
+		"use strict";
+		a.r(e);
+		var n = a(0),
+			o = a(1);
+		Object(n.combineWithMathJax)({
+			_: { input: { tex: { configmacros: { ConfigMacrosConfiguration: o } } } },
+		}),
+			(function (t, e, a) {
+				var o,
+					i,
+					r,
+					u = MathJax.config.tex;
+				if (u && u.packages) {
+					var c = u.packages,
+						l = c.indexOf(t);
+					l >= 0 && (c[l] = e),
+						a &&
+							u[t] &&
+							(Object(n.combineConfig)(
+								u,
+								((o = {}),
+								(i = e),
+								(r = u[t]),
+								i in o
+									? Object.defineProperty(o, i, {
+											value: r,
+											enumerable: !0,
+											configurable: !0,
+											writable: !0,
+										})
+									: (o[i] = r),
+								o),
+							),
+							delete u[t]);
+				}
+			})("configMacros", "configmacros", !1);
+	},
+]);

assets/bower_components/MathJax/es5/input/tex/extensions/enclose.js

@@ -0,0 +1,128 @@
+!(function (e) {
+	var t = {};
+	function a(n) {
+		if (t[n]) return t[n].exports;
+		var o = (t[n] = { i: n, l: !1, exports: {} });
+		return e[n].call(o.exports, o, o.exports, a), (o.l = !0), o.exports;
+	}
+	(a.m = e),
+		(a.c = t),
+		(a.d = function (e, t, n) {
+			a.o(e, t) || Object.defineProperty(e, t, { enumerable: !0, get: n });
+		}),
+		(a.r = function (e) {
+			"undefined" != typeof Symbol &&
+				Symbol.toStringTag &&
+				Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }),
+				Object.defineProperty(e, "__esModule", { value: !0 });
+		}),
+		(a.t = function (e, t) {
+			if ((1 & t && (e = a(e)), 8 & t)) return e;
+			if (4 & t && "object" == typeof e && e && e.__esModule) return e;
+			var n = Object.create(null);
+			if (
+				(a.r(n),
+				Object.defineProperty(n, "default", { enumerable: !0, value: e }),
+				2 & t && "string" != typeof e)
+			)
+				for (var o in e)
+					a.d(
+						n,
+						o,
+						function (t) {
+							return e[t];
+						}.bind(null, o),
+					);
+			return n;
+		}),
+		(a.n = function (e) {
+			var t =
+				e && e.__esModule
+					? function () {
+							return e.default;
+						}
+					: function () {
+							return e;
+						};
+			return a.d(t, "a", t), t;
+		}),
+		(a.o = function (e, t) {
+			return Object.prototype.hasOwnProperty.call(e, t);
+		}),
+		(a.p = ""),
+		a((a.s = 5));
+})([
+	function (e, t, a) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.isObject = MathJax._.components.global.isObject),
+			(t.combineConfig = MathJax._.components.global.combineConfig),
+			(t.combineDefaults = MathJax._.components.global.combineDefaults),
+			(t.combineWithMathJax = MathJax._.components.global.combineWithMathJax),
+			(t.MathJax = MathJax._.components.global.MathJax);
+	},
+	function (e, t, a) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.EncloseConfiguration = t.EncloseMethods = t.ENCLOSE_OPTIONS = void 0);
+		var n = a(2),
+			o = a(3),
+			r = a(4);
+		(t.ENCLOSE_OPTIONS = {
+			"data-arrowhead": 1,
+			color: 1,
+			mathcolor: 1,
+			background: 1,
+			mathbackground: 1,
+			"data-padding": 1,
+			"data-thickness": 1,
+		}),
+			(t.EncloseMethods = {}),
+			(t.EncloseMethods.Enclose = function (e, a) {
+				var n = e.GetArgument(a).replace(/,/g, " "),
+					o = e.GetBrackets(a, ""),
+					i = e.ParseArg(a),
+					u = r.default.keyvalOptions(o, t.ENCLOSE_OPTIONS);
+				(u.notation = n), e.Push(e.create("node", "menclose", [i], u));
+			}),
+			new o.CommandMap("enclose", { enclose: "Enclose" }, t.EncloseMethods),
+			(t.EncloseConfiguration = n.Configuration.create("enclose", {
+				handler: { macro: ["enclose"] },
+			}));
+	},
+	function (e, t, a) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.Configuration = MathJax._.input.tex.Configuration.Configuration),
+			(t.ConfigurationHandler =
+				MathJax._.input.tex.Configuration.ConfigurationHandler),
+			(t.ParserConfiguration =
+				MathJax._.input.tex.Configuration.ParserConfiguration);
+	},
+	function (e, t, a) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.AbstractSymbolMap = MathJax._.input.tex.SymbolMap.AbstractSymbolMap),
+			(t.RegExpMap = MathJax._.input.tex.SymbolMap.RegExpMap),
+			(t.AbstractParseMap = MathJax._.input.tex.SymbolMap.AbstractParseMap),
+			(t.CharacterMap = MathJax._.input.tex.SymbolMap.CharacterMap),
+			(t.DelimiterMap = MathJax._.input.tex.SymbolMap.DelimiterMap),
+			(t.MacroMap = MathJax._.input.tex.SymbolMap.MacroMap),
+			(t.CommandMap = MathJax._.input.tex.SymbolMap.CommandMap),
+			(t.EnvironmentMap = MathJax._.input.tex.SymbolMap.EnvironmentMap);
+	},
+	function (e, t, a) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.default = MathJax._.input.tex.ParseUtil.default);
+	},
+	function (e, t, a) {
+		"use strict";
+		a.r(t);
+		var n = a(0),
+			o = a(1);
+		Object(n.combineWithMathJax)({
+			_: { input: { tex: { enclose: { EncloseConfiguration: o } } } },
+		});
+	},
+]);

assets/bower_components/MathJax/es5/input/tex/extensions/extpfeil.js

@@ -0,0 +1,177 @@
+!(function (t) {
+	var e = {};
+	function a(o) {
+		if (e[o]) return e[o].exports;
+		var n = (e[o] = { i: o, l: !1, exports: {} });
+		return t[o].call(n.exports, n, n.exports, a), (n.l = !0), n.exports;
+	}
+	(a.m = t),
+		(a.c = e),
+		(a.d = function (t, e, o) {
+			a.o(t, e) || Object.defineProperty(t, e, { enumerable: !0, get: o });
+		}),
+		(a.r = function (t) {
+			"undefined" != typeof Symbol &&
+				Symbol.toStringTag &&
+				Object.defineProperty(t, Symbol.toStringTag, { value: "Module" }),
+				Object.defineProperty(t, "__esModule", { value: !0 });
+		}),
+		(a.t = function (t, e) {
+			if ((1 & e && (t = a(t)), 8 & e)) return t;
+			if (4 & e && "object" == typeof t && t && t.__esModule) return t;
+			var o = Object.create(null);
+			if (
+				(a.r(o),
+				Object.defineProperty(o, "default", { enumerable: !0, value: t }),
+				2 & e && "string" != typeof t)
+			)
+				for (var n in t)
+					a.d(
+						o,
+						n,
+						function (e) {
+							return t[e];
+						}.bind(null, n),
+					);
+			return o;
+		}),
+		(a.n = function (t) {
+			var e =
+				t && t.__esModule
+					? function () {
+							return t.default;
+						}
+					: function () {
+							return t;
+						};
+			return a.d(e, "a", e), e;
+		}),
+		(a.o = function (t, e) {
+			return Object.prototype.hasOwnProperty.call(t, e);
+		}),
+		(a.p = ""),
+		a((a.s = 8));
+})([
+	function (t, e, a) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.isObject = MathJax._.components.global.isObject),
+			(e.combineConfig = MathJax._.components.global.combineConfig),
+			(e.combineDefaults = MathJax._.components.global.combineDefaults),
+			(e.combineWithMathJax = MathJax._.components.global.combineWithMathJax),
+			(e.MathJax = MathJax._.components.global.MathJax);
+	},
+	function (t, e, a) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.ExtpfeilConfiguration = e.ExtpfeilMethods = void 0);
+		var o = a(2),
+			n = a(3),
+			r = a(4),
+			i = a(5),
+			u = a(6),
+			l = a(7);
+		(e.ExtpfeilMethods = {}),
+			(e.ExtpfeilMethods.xArrow = r.AmsMethods.xArrow),
+			(e.ExtpfeilMethods.NewExtArrow = function (t, a) {
+				var o = t.GetArgument(a),
+					n = t.GetArgument(a),
+					r = t.GetArgument(a);
+				if (!o.match(/^\\([a-z]+|.)$/i))
+					throw new l.default(
+						"NewextarrowArg1",
+						"First argument to %1 must be a control sequence name",
+						a,
+					);
+				if (!n.match(/^(\d+),(\d+)$/))
+					throw new l.default(
+						"NewextarrowArg2",
+						"Second argument to %1 must be two integers separated by a comma",
+						a,
+					);
+				if (!r.match(/^(\d+|0x[0-9A-F]+)$/i))
+					throw new l.default(
+						"NewextarrowArg3",
+						"Third argument to %1 must be a unicode character number",
+						a,
+					);
+				o = o.substr(1);
+				var u = n.split(",");
+				i.default.addMacro(t, o, e.ExtpfeilMethods.xArrow, [
+					parseInt(r),
+					parseInt(u[0]),
+					parseInt(u[1]),
+				]);
+			}),
+			new n.CommandMap(
+				"extpfeil",
+				{
+					xtwoheadrightarrow: ["xArrow", 8608, 12, 16],
+					xtwoheadleftarrow: ["xArrow", 8606, 17, 13],
+					xmapsto: ["xArrow", 8614, 6, 7],
+					xlongequal: ["xArrow", 61, 7, 7],
+					xtofrom: ["xArrow", 8644, 12, 12],
+					Newextarrow: "NewExtArrow",
+				},
+				e.ExtpfeilMethods,
+			);
+		e.ExtpfeilConfiguration = o.Configuration.create("extpfeil", {
+			handler: { macro: ["extpfeil"] },
+			init: function (t) {
+				u.NewcommandConfiguration.init(t);
+			},
+		});
+	},
+	function (t, e, a) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.Configuration = MathJax._.input.tex.Configuration.Configuration),
+			(e.ConfigurationHandler =
+				MathJax._.input.tex.Configuration.ConfigurationHandler),
+			(e.ParserConfiguration =
+				MathJax._.input.tex.Configuration.ParserConfiguration);
+	},
+	function (t, e, a) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.AbstractSymbolMap = MathJax._.input.tex.SymbolMap.AbstractSymbolMap),
+			(e.RegExpMap = MathJax._.input.tex.SymbolMap.RegExpMap),
+			(e.AbstractParseMap = MathJax._.input.tex.SymbolMap.AbstractParseMap),
+			(e.CharacterMap = MathJax._.input.tex.SymbolMap.CharacterMap),
+			(e.DelimiterMap = MathJax._.input.tex.SymbolMap.DelimiterMap),
+			(e.MacroMap = MathJax._.input.tex.SymbolMap.MacroMap),
+			(e.CommandMap = MathJax._.input.tex.SymbolMap.CommandMap),
+			(e.EnvironmentMap = MathJax._.input.tex.SymbolMap.EnvironmentMap);
+	},
+	function (t, e, a) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.AmsMethods = MathJax._.input.tex.ams.AmsMethods.AmsMethods),
+			(e.NEW_OPS = MathJax._.input.tex.ams.AmsMethods.NEW_OPS);
+	},
+	function (t, e, a) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.default = MathJax._.input.tex.newcommand.NewcommandUtil.default);
+	},
+	function (t, e, a) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.NewcommandConfiguration =
+				MathJax._.input.tex.newcommand.NewcommandConfiguration.NewcommandConfiguration);
+	},
+	function (t, e, a) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.default = MathJax._.input.tex.TexError.default);
+	},
+	function (t, e, a) {
+		"use strict";
+		a.r(e);
+		var o = a(0),
+			n = a(1);
+		Object(o.combineWithMathJax)({
+			_: { input: { tex: { extpfeil: { ExtpfeilConfiguration: n } } } },
+		});
+	},
+]);

assets/bower_components/MathJax/es5/input/tex/extensions/html.js

@@ -0,0 +1,159 @@
+!(function (t) {
+	var e = {};
+	function a(n) {
+		if (e[n]) return e[n].exports;
+		var r = (e[n] = { i: n, l: !1, exports: {} });
+		return t[n].call(r.exports, r, r.exports, a), (r.l = !0), r.exports;
+	}
+	(a.m = t),
+		(a.c = e),
+		(a.d = function (t, e, n) {
+			a.o(t, e) || Object.defineProperty(t, e, { enumerable: !0, get: n });
+		}),
+		(a.r = function (t) {
+			"undefined" != typeof Symbol &&
+				Symbol.toStringTag &&
+				Object.defineProperty(t, Symbol.toStringTag, { value: "Module" }),
+				Object.defineProperty(t, "__esModule", { value: !0 });
+		}),
+		(a.t = function (t, e) {
+			if ((1 & e && (t = a(t)), 8 & e)) return t;
+			if (4 & e && "object" == typeof t && t && t.__esModule) return t;
+			var n = Object.create(null);
+			if (
+				(a.r(n),
+				Object.defineProperty(n, "default", { enumerable: !0, value: t }),
+				2 & e && "string" != typeof t)
+			)
+				for (var r in t)
+					a.d(
+						n,
+						r,
+						function (e) {
+							return t[e];
+						}.bind(null, r),
+					);
+			return n;
+		}),
+		(a.n = function (t) {
+			var e =
+				t && t.__esModule
+					? function () {
+							return t.default;
+						}
+					: function () {
+							return t;
+						};
+			return a.d(e, "a", e), e;
+		}),
+		(a.o = function (t, e) {
+			return Object.prototype.hasOwnProperty.call(t, e);
+		}),
+		(a.p = ""),
+		a((a.s = 6));
+})([
+	function (t, e, a) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 });
+		var n = a(5),
+			r = {
+				Href: function (t, e) {
+					var a = t.GetArgument(e),
+						r = o(t, e);
+					n.default.setAttribute(r, "href", a), t.Push(r);
+				},
+				Class: function (t, e) {
+					var a = t.GetArgument(e),
+						r = o(t, e),
+						u = n.default.getAttribute(r, "class");
+					u && (a = u + " " + a),
+						n.default.setAttribute(r, "class", a),
+						t.Push(r);
+				},
+				Style: function (t, e) {
+					var a = t.GetArgument(e),
+						r = o(t, e),
+						u = n.default.getAttribute(r, "style");
+					u &&
+						(";" !== a.charAt(a.length - 1) && (a += ";"), (a = u + " " + a)),
+						n.default.setAttribute(r, "style", a),
+						t.Push(r);
+				},
+				Id: function (t, e) {
+					var a = t.GetArgument(e),
+						r = o(t, e);
+					n.default.setAttribute(r, "id", a), t.Push(r);
+				},
+			},
+			o = function (t, e) {
+				var a = t.ParseArg(e);
+				if (!n.default.isInferred(a)) return a;
+				var r = n.default.getChildren(a);
+				if (1 === r.length) return r[0];
+				var o = t.create("node", "mrow");
+				return n.default.copyChildren(a, o), n.default.copyAttributes(a, o), o;
+			};
+		e.default = r;
+	},
+	function (t, e, a) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.isObject = MathJax._.components.global.isObject),
+			(e.combineConfig = MathJax._.components.global.combineConfig),
+			(e.combineDefaults = MathJax._.components.global.combineDefaults),
+			(e.combineWithMathJax = MathJax._.components.global.combineWithMathJax),
+			(e.MathJax = MathJax._.components.global.MathJax);
+	},
+	function (t, e, a) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.HtmlConfiguration = void 0);
+		var n = a(3),
+			r = a(4),
+			o = a(0);
+		new r.CommandMap(
+			"html_macros",
+			{ href: "Href", class: "Class", style: "Style", cssId: "Id" },
+			o.default,
+		),
+			(e.HtmlConfiguration = n.Configuration.create("html", {
+				handler: { macro: ["html_macros"] },
+			}));
+	},
+	function (t, e, a) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.Configuration = MathJax._.input.tex.Configuration.Configuration),
+			(e.ConfigurationHandler =
+				MathJax._.input.tex.Configuration.ConfigurationHandler),
+			(e.ParserConfiguration =
+				MathJax._.input.tex.Configuration.ParserConfiguration);
+	},
+	function (t, e, a) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.AbstractSymbolMap = MathJax._.input.tex.SymbolMap.AbstractSymbolMap),
+			(e.RegExpMap = MathJax._.input.tex.SymbolMap.RegExpMap),
+			(e.AbstractParseMap = MathJax._.input.tex.SymbolMap.AbstractParseMap),
+			(e.CharacterMap = MathJax._.input.tex.SymbolMap.CharacterMap),
+			(e.DelimiterMap = MathJax._.input.tex.SymbolMap.DelimiterMap),
+			(e.MacroMap = MathJax._.input.tex.SymbolMap.MacroMap),
+			(e.CommandMap = MathJax._.input.tex.SymbolMap.CommandMap),
+			(e.EnvironmentMap = MathJax._.input.tex.SymbolMap.EnvironmentMap);
+	},
+	function (t, e, a) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.default = MathJax._.input.tex.NodeUtil.default);
+	},
+	function (t, e, a) {
+		"use strict";
+		a.r(e);
+		var n = a(1),
+			r = a(2),
+			o = a(0);
+		Object(n.combineWithMathJax)({
+			_: { input: { tex: { html: { HtmlConfiguration: r, HtmlMethods: o } } } },
+		});
+	},
+]);

assets/bower_components/MathJax/es5/input/tex/extensions/newcommand.js

@@ -0,0 +1,532 @@
+!(function (e) {
+	var t = {};
+	function a(n) {
+		if (t[n]) return t[n].exports;
+		var r = (t[n] = { i: n, l: !1, exports: {} });
+		return e[n].call(r.exports, r, r.exports, a), (r.l = !0), r.exports;
+	}
+	(a.m = e),
+		(a.c = t),
+		(a.d = function (e, t, n) {
+			a.o(e, t) || Object.defineProperty(e, t, { enumerable: !0, get: n });
+		}),
+		(a.r = function (e) {
+			"undefined" != typeof Symbol &&
+				Symbol.toStringTag &&
+				Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }),
+				Object.defineProperty(e, "__esModule", { value: !0 });
+		}),
+		(a.t = function (e, t) {
+			if ((1 & t && (e = a(e)), 8 & t)) return e;
+			if (4 & t && "object" == typeof e && e && e.__esModule) return e;
+			var n = Object.create(null);
+			if (
+				(a.r(n),
+				Object.defineProperty(n, "default", { enumerable: !0, value: e }),
+				2 & t && "string" != typeof e)
+			)
+				for (var r in e)
+					a.d(
+						n,
+						r,
+						function (t) {
+							return e[t];
+						}.bind(null, r),
+					);
+			return n;
+		}),
+		(a.n = function (e) {
+			var t =
+				e && e.__esModule
+					? function () {
+							return e.default;
+						}
+					: function () {
+							return e;
+						};
+			return a.d(t, "a", t), t;
+		}),
+		(a.o = function (e, t) {
+			return Object.prototype.hasOwnProperty.call(e, t);
+		}),
+		(a.p = ""),
+		a((a.s = 14));
+})([
+	function (e, t, a) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 });
+		var n,
+			r = a(5),
+			i = a(1),
+			o = a(10);
+		!(function (e) {
+			function t(e, t) {
+				return e.string.substr(e.i, t.length) !== t ||
+					(t.match(/\\[a-z]+$/i) &&
+						e.string.charAt(e.i + t.length).match(/[a-z]/i))
+					? 0
+					: ((e.i += t.length), 1);
+			}
+			(e.disassembleSymbol = function (e, t) {
+				var a = [e, t.char];
+				if (t.attributes)
+					for (var n in t.attributes) a.push(n), a.push(t.attributes[n]);
+				return a;
+			}),
+				(e.assembleSymbol = function (e) {
+					for (var t = e[0], a = e[1], n = {}, r = 2; r < e.length; r += 2)
+						n[e[r]] = e[r + 1];
+					return new o.Symbol(t, a, n);
+				}),
+				(e.GetCSname = function (e, t) {
+					if ("\\" !== e.GetNext())
+						throw new i.default(
+							"MissingCS",
+							"%1 must be followed by a control sequence",
+							t,
+						);
+					return r.default.trimSpaces(e.GetArgument(t)).substr(1);
+				}),
+				(e.GetTemplate = function (e, t, a) {
+					for (
+						var n = e.GetNext(), r = [], o = 0, u = e.i;
+						e.i < e.string.length;
+					) {
+						if ("#" === (n = e.GetNext())) {
+							if (
+								(u !== e.i && (r[o] = e.string.substr(u, e.i - u)),
+								!(n = e.string.charAt(++e.i)).match(/^[1-9]$/))
+							)
+								throw new i.default(
+									"CantUseHash2",
+									"Illegal use of # in template for %1",
+									a,
+								);
+							if (parseInt(n) !== ++o)
+								throw new i.default(
+									"SequentialParam",
+									"Parameters for %1 must be numbered sequentially",
+									a,
+								);
+							u = e.i + 1;
+						} else if ("{" === n)
+							return (
+								u !== e.i && (r[o] = e.string.substr(u, e.i - u)),
+								r.length > 0 ? [o.toString()].concat(r) : o
+							);
+						e.i++;
+					}
+					throw new i.default(
+						"MissingReplacementString",
+						"Missing replacement string for definition of %1",
+						t,
+					);
+				}),
+				(e.GetParameter = function (e, a, n) {
+					if (null == n) return e.GetArgument(a);
+					for (var r = e.i, o = 0, u = 0; e.i < e.string.length; ) {
+						var l = e.string.charAt(e.i);
+						if ("{" === l)
+							e.i === r && (u = 1), e.GetArgument(a), (o = e.i - r);
+						else {
+							if (t(e, n)) return u && (r++, (o -= 2)), e.string.substr(r, o);
+							if ("\\" === l) {
+								e.i++, o++, (u = 0);
+								var c = e.string.substr(e.i).match(/[a-z]+|./i);
+								c && ((e.i += c[0].length), (o = e.i - r));
+							} else e.i++, o++, (u = 0);
+						}
+					}
+					throw new i.default("RunawayArgument", "Runaway argument for %1?", a);
+				}),
+				(e.MatchParam = t),
+				(e.addDelimiter = function (t, a, n, r) {
+					t.configuration.handlers
+						.retrieve(e.NEW_DELIMITER)
+						.add(a, new o.Symbol(a, n, r));
+				}),
+				(e.addMacro = function (t, a, n, r, i) {
+					void 0 === i && (i = ""),
+						t.configuration.handlers
+							.retrieve(e.NEW_COMMAND)
+							.add(a, new o.Macro(i || a, n, r));
+				}),
+				(e.addEnvironment = function (t, a, n, r) {
+					t.configuration.handlers
+						.retrieve(e.NEW_ENVIRONMENT)
+						.add(a, new o.Macro(a, n, r));
+				}),
+				(e.NEW_DELIMITER = "new-Delimiter"),
+				(e.NEW_COMMAND = "new-Command"),
+				(e.NEW_ENVIRONMENT = "new-Environment");
+		})(n || (n = {})),
+			(t.default = n);
+	},
+	function (e, t, a) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.default = MathJax._.input.tex.TexError.default);
+	},
+	function (e, t, a) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.AbstractSymbolMap = MathJax._.input.tex.SymbolMap.AbstractSymbolMap),
+			(t.RegExpMap = MathJax._.input.tex.SymbolMap.RegExpMap),
+			(t.AbstractParseMap = MathJax._.input.tex.SymbolMap.AbstractParseMap),
+			(t.CharacterMap = MathJax._.input.tex.SymbolMap.CharacterMap),
+			(t.DelimiterMap = MathJax._.input.tex.SymbolMap.DelimiterMap),
+			(t.MacroMap = MathJax._.input.tex.SymbolMap.MacroMap),
+			(t.CommandMap = MathJax._.input.tex.SymbolMap.CommandMap),
+			(t.EnvironmentMap = MathJax._.input.tex.SymbolMap.EnvironmentMap);
+	},
+	function (e, t, a) {
+		"use strict";
+		var n,
+			r =
+				(this && this.__extends) ||
+				((n = function (e, t) {
+					return (n =
+						Object.setPrototypeOf ||
+						({ __proto__: [] } instanceof Array &&
+							function (e, t) {
+								e.__proto__ = t;
+							}) ||
+						function (e, t) {
+							for (var a in t) t.hasOwnProperty(a) && (e[a] = t[a]);
+						})(e, t);
+				}),
+				function (e, t) {
+					function a() {
+						this.constructor = e;
+					}
+					n(e, t),
+						(e.prototype =
+							null === t
+								? Object.create(t)
+								: ((a.prototype = t.prototype), new a()));
+				});
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.BeginEnvItem = void 0);
+		var i = a(1),
+			o = (function (e) {
+				function t() {
+					return (null !== e && e.apply(this, arguments)) || this;
+				}
+				return (
+					r(t, e),
+					Object.defineProperty(t.prototype, "kind", {
+						get: function () {
+							return "beginEnv";
+						},
+						enumerable: !1,
+						configurable: !0,
+					}),
+					Object.defineProperty(t.prototype, "isOpen", {
+						get: function () {
+							return !0;
+						},
+						enumerable: !1,
+						configurable: !0,
+					}),
+					(t.prototype.checkItem = function (t) {
+						if (t.isKind("end")) {
+							if (t.getName() !== this.getName())
+								throw new i.default(
+									"EnvBadEnd",
+									"\\begin{%1} ended with \\end{%2}",
+									this.getName(),
+									t.getName(),
+								);
+							return [[this.factory.create("mml", this.toMml())], !0];
+						}
+						if (t.isKind("stop"))
+							throw new i.default(
+								"EnvMissingEnd",
+								"Missing \\end{%1}",
+								this.getName(),
+							);
+						return e.prototype.checkItem.call(this, t);
+					}),
+					t
+				);
+			})(a(9).BaseItem);
+		t.BeginEnvItem = o;
+	},
+	function (e, t, a) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 });
+		var n = a(1),
+			r = a(2),
+			i = a(12),
+			o = a(5),
+			u = a(0),
+			l = {
+				NewCommand: function (e, t) {
+					var a = o.default.trimSpaces(e.GetArgument(t)),
+						r = e.GetBrackets(t),
+						i = e.GetBrackets(t),
+						c = e.GetArgument(t);
+					if (
+						("\\" === a.charAt(0) && (a = a.substr(1)),
+						!a.match(/^(.|[a-z]+)$/i))
+					)
+						throw new n.default(
+							"IllegalControlSequenceName",
+							"Illegal control sequence name for %1",
+							t,
+						);
+					if (r && !(r = o.default.trimSpaces(r)).match(/^[0-9]+$/))
+						throw new n.default(
+							"IllegalParamNumber",
+							"Illegal number of parameters specified in %1",
+							t,
+						);
+					u.default.addMacro(e, a, l.Macro, [c, r, i]);
+				},
+				NewEnvironment: function (e, t) {
+					var a = o.default.trimSpaces(e.GetArgument(t)),
+						r = e.GetBrackets(t),
+						i = e.GetBrackets(t),
+						c = e.GetArgument(t),
+						s = e.GetArgument(t);
+					if (r && !(r = o.default.trimSpaces(r)).match(/^[0-9]+$/))
+						throw new n.default(
+							"IllegalParamNumber",
+							"Illegal number of parameters specified in %1",
+							t,
+						);
+					u.default.addEnvironment(e, a, l.BeginEnv, [!0, c, s, r, i]);
+				},
+				MacroDef: function (e, t) {
+					var a = u.default.GetCSname(e, t),
+						n = u.default.GetTemplate(e, t, "\\" + a),
+						r = e.GetArgument(t);
+					n instanceof Array
+						? u.default.addMacro(e, a, l.MacroWithTemplate, [r].concat(n))
+						: u.default.addMacro(e, a, l.Macro, [r, n]);
+				},
+				Let: function (e, t) {
+					var a = u.default.GetCSname(e, t),
+						n = e.GetNext();
+					"=" === n && (e.i++, (n = e.GetNext()));
+					var i = e.configuration.handlers;
+					if ("\\" !== n) {
+						e.i++;
+						var o = i.get("delimiter").lookup(n);
+						o
+							? u.default.addDelimiter(e, "\\" + a, o.char, o.attributes)
+							: u.default.addMacro(e, a, l.Macro, [n]);
+					} else {
+						t = u.default.GetCSname(e, t);
+						var c = i.get("delimiter").lookup("\\" + t);
+						if (c)
+							return void u.default.addDelimiter(
+								e,
+								"\\" + a,
+								c.char,
+								c.attributes,
+							);
+						var s = i.get("macro").applicable(t);
+						if (!s) return;
+						if (s instanceof r.MacroMap) {
+							var f = s.lookup(t);
+							return void u.default.addMacro(e, a, f.func, f.args, f.symbol);
+						}
+						c = s.lookup(t);
+						var m = u.default.disassembleSymbol(a, c);
+						u.default.addMacro(
+							e,
+							a,
+							function (e, t) {
+								for (var a = [], n = 2; n < arguments.length; n++)
+									a[n - 2] = arguments[n];
+								var r = u.default.assembleSymbol(a);
+								return s.parser(e, r);
+							},
+							m,
+						);
+					}
+				},
+				MacroWithTemplate: function (e, t, a, r) {
+					for (var i = [], l = 4; l < arguments.length; l++)
+						i[l - 4] = arguments[l];
+					var c = parseInt(r, 10);
+					if (c) {
+						var s = [];
+						if ((e.GetNext(), i[0] && !u.default.MatchParam(e, i[0])))
+							throw new n.default(
+								"MismatchUseDef",
+								"Use of %1 doesn't match its definition",
+								t,
+							);
+						for (var f = 0; f < c; f++)
+							s.push(u.default.GetParameter(e, t, i[f + 1]));
+						a = o.default.substituteArgs(e, s, a);
+					}
+					if (
+						((e.string = o.default.addArgs(e, a, e.string.slice(e.i))),
+						(e.i = 0),
+						++e.macroCount > e.configuration.options.maxMacros)
+					)
+						throw new n.default(
+							"MaxMacroSub1",
+							"MathJax maximum macro substitution count exceeded; is here a recursive macro call?",
+						);
+				},
+				BeginEnv: function (e, t, a, n, r, i) {
+					if (t.getProperty("end") && e.stack.env.closing === t.getName()) {
+						delete e.stack.env.closing;
+						var u = e.string.slice(e.i);
+						return (
+							(e.string = n),
+							(e.i = 0),
+							e.Parse(),
+							(e.string = u),
+							(e.i = 0),
+							e.itemFactory.create("end").setProperty("name", t.getName())
+						);
+					}
+					if (r) {
+						var l = [];
+						if (null != i) {
+							var c = e.GetBrackets("\\begin{" + t.getName() + "}");
+							l.push(null == c ? i : c);
+						}
+						for (var s = l.length; s < r; s++)
+							l.push(e.GetArgument("\\begin{" + t.getName() + "}"));
+						(a = o.default.substituteArgs(e, l, a)),
+							(n = o.default.substituteArgs(e, [], n));
+					}
+					return (
+						(e.string = o.default.addArgs(e, a, e.string.slice(e.i))),
+						(e.i = 0),
+						e.itemFactory.create("beginEnv").setProperty("name", t.getName())
+					);
+				},
+			};
+		(l.Macro = i.default.Macro), (t.default = l);
+	},
+	function (e, t, a) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.default = MathJax._.input.tex.ParseUtil.default);
+	},
+	function (e, t, a) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.isObject = MathJax._.components.global.isObject),
+			(t.combineConfig = MathJax._.components.global.combineConfig),
+			(t.combineDefaults = MathJax._.components.global.combineDefaults),
+			(t.combineWithMathJax = MathJax._.components.global.combineWithMathJax),
+			(t.MathJax = MathJax._.components.global.MathJax);
+	},
+	function (e, t, a) {
+		"use strict";
+		var n;
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.NewcommandConfiguration = void 0);
+		var r = a(8),
+			i = a(3),
+			o = a(0);
+		a(11);
+		var u = a(13),
+			l = a(2);
+		t.NewcommandConfiguration = r.Configuration.create("newcommand", {
+			handler: { macro: ["Newcommand-macros"] },
+			items: ((n = {}), (n[i.BeginEnvItem.prototype.kind] = i.BeginEnvItem), n),
+			options: { maxMacros: 1e3 },
+			init: function (e) {
+				new l.DelimiterMap(o.default.NEW_DELIMITER, u.default.delimiter, {}),
+					new l.CommandMap(o.default.NEW_COMMAND, {}, {}),
+					new l.EnvironmentMap(
+						o.default.NEW_ENVIRONMENT,
+						u.default.environment,
+						{},
+						{},
+					),
+					e.append(
+						r.Configuration.local({
+							handler: {
+								character: [],
+								delimiter: [o.default.NEW_DELIMITER],
+								macro: [o.default.NEW_DELIMITER, o.default.NEW_COMMAND],
+								environment: [o.default.NEW_ENVIRONMENT],
+							},
+							priority: -1,
+						}),
+					);
+			},
+		});
+	},
+	function (e, t, a) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.Configuration = MathJax._.input.tex.Configuration.Configuration),
+			(t.ConfigurationHandler =
+				MathJax._.input.tex.Configuration.ConfigurationHandler),
+			(t.ParserConfiguration =
+				MathJax._.input.tex.Configuration.ParserConfiguration);
+	},
+	function (e, t, a) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.MmlStack = MathJax._.input.tex.StackItem.MmlStack),
+			(t.BaseItem = MathJax._.input.tex.StackItem.BaseItem);
+	},
+	function (e, t, a) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.Symbol = MathJax._.input.tex.Symbol.Symbol),
+			(t.Macro = MathJax._.input.tex.Symbol.Macro);
+	},
+	function (e, t, a) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 });
+		var n = a(4);
+		new (a(2).CommandMap)(
+			"Newcommand-macros",
+			{
+				newcommand: "NewCommand",
+				renewcommand: "NewCommand",
+				newenvironment: "NewEnvironment",
+				renewenvironment: "NewEnvironment",
+				def: "MacroDef",
+				let: "Let",
+			},
+			n.default,
+		);
+	},
+	function (e, t, a) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.default = MathJax._.input.tex.base.BaseMethods.default);
+	},
+	function (e, t, a) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.default = MathJax._.input.tex.ParseMethods.default);
+	},
+	function (e, t, a) {
+		"use strict";
+		a.r(t);
+		var n = a(6),
+			r = a(7),
+			i = a(3),
+			o = a(4),
+			u = a(0);
+		Object(n.combineWithMathJax)({
+			_: {
+				input: {
+					tex: {
+						newcommand: {
+							NewcommandConfiguration: r,
+							NewcommandItems: i,
+							NewcommandMethods: o,
+							NewcommandUtil: u,
+						},
+					},
+				},
+			},
+		});
+	},
+]);

assets/bower_components/MathJax/es5/input/tex/extensions/noerrors.js

@@ -0,0 +1,99 @@
+!(function (e) {
+	var t = {};
+	function n(o) {
+		if (t[o]) return t[o].exports;
+		var r = (t[o] = { i: o, l: !1, exports: {} });
+		return e[o].call(r.exports, r, r.exports, n), (r.l = !0), r.exports;
+	}
+	(n.m = e),
+		(n.c = t),
+		(n.d = function (e, t, o) {
+			n.o(e, t) || Object.defineProperty(e, t, { enumerable: !0, get: o });
+		}),
+		(n.r = function (e) {
+			"undefined" != typeof Symbol &&
+				Symbol.toStringTag &&
+				Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }),
+				Object.defineProperty(e, "__esModule", { value: !0 });
+		}),
+		(n.t = function (e, t) {
+			if ((1 & t && (e = n(e)), 8 & t)) return e;
+			if (4 & t && "object" == typeof e && e && e.__esModule) return e;
+			var o = Object.create(null);
+			if (
+				(n.r(o),
+				Object.defineProperty(o, "default", { enumerable: !0, value: e }),
+				2 & t && "string" != typeof e)
+			)
+				for (var r in e)
+					n.d(
+						o,
+						r,
+						function (t) {
+							return e[t];
+						}.bind(null, r),
+					);
+			return o;
+		}),
+		(n.n = function (e) {
+			var t =
+				e && e.__esModule
+					? function () {
+							return e.default;
+						}
+					: function () {
+							return e;
+						};
+			return n.d(t, "a", t), t;
+		}),
+		(n.o = function (e, t) {
+			return Object.prototype.hasOwnProperty.call(e, t);
+		}),
+		(n.p = ""),
+		n((n.s = 3));
+})([
+	function (e, t, n) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.isObject = MathJax._.components.global.isObject),
+			(t.combineConfig = MathJax._.components.global.combineConfig),
+			(t.combineDefaults = MathJax._.components.global.combineDefaults),
+			(t.combineWithMathJax = MathJax._.components.global.combineWithMathJax),
+			(t.MathJax = MathJax._.components.global.MathJax);
+	},
+	function (e, t, n) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.NoErrorsConfiguration = void 0);
+		var o = n(2);
+		t.NoErrorsConfiguration = o.Configuration.create("noerrors", {
+			nodes: {
+				error: function (e, t, n, o) {
+					var r = e.create("token", "mtext", {}, o.replace(/\n/g, " "));
+					return e.create("node", "merror", [r], {
+						"data-mjx-error": t,
+						title: t,
+					});
+				},
+			},
+		});
+	},
+	function (e, t, n) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.Configuration = MathJax._.input.tex.Configuration.Configuration),
+			(t.ConfigurationHandler =
+				MathJax._.input.tex.Configuration.ConfigurationHandler),
+			(t.ParserConfiguration =
+				MathJax._.input.tex.Configuration.ParserConfiguration);
+	},
+	function (e, t, n) {
+		"use strict";
+		n.r(t);
+		var o = n(0),
+			r = n(1);
+		Object(o.combineWithMathJax)({
+			_: { input: { tex: { noerrors: { NoErrorsConfiguration: r } } } },
+		});
+	},
+]);

assets/bower_components/MathJax/es5/input/tex/extensions/noundefined.js

@@ -0,0 +1,140 @@
+!(function (e) {
+	var n = {};
+	function t(o) {
+		if (n[o]) return n[o].exports;
+		var r = (n[o] = { i: o, l: !1, exports: {} });
+		return e[o].call(r.exports, r, r.exports, t), (r.l = !0), r.exports;
+	}
+	(t.m = e),
+		(t.c = n),
+		(t.d = function (e, n, o) {
+			t.o(e, n) || Object.defineProperty(e, n, { enumerable: !0, get: o });
+		}),
+		(t.r = function (e) {
+			"undefined" != typeof Symbol &&
+				Symbol.toStringTag &&
+				Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }),
+				Object.defineProperty(e, "__esModule", { value: !0 });
+		}),
+		(t.t = function (e, n) {
+			if ((1 & n && (e = t(e)), 8 & n)) return e;
+			if (4 & n && "object" == typeof e && e && e.__esModule) return e;
+			var o = Object.create(null);
+			if (
+				(t.r(o),
+				Object.defineProperty(o, "default", { enumerable: !0, value: e }),
+				2 & n && "string" != typeof e)
+			)
+				for (var r in e)
+					t.d(
+						o,
+						r,
+						function (n) {
+							return e[n];
+						}.bind(null, r),
+					);
+			return o;
+		}),
+		(t.n = function (e) {
+			var n =
+				e && e.__esModule
+					? function () {
+							return e.default;
+						}
+					: function () {
+							return e;
+						};
+			return t.d(n, "a", n), n;
+		}),
+		(t.o = function (e, n) {
+			return Object.prototype.hasOwnProperty.call(e, n);
+		}),
+		(t.p = ""),
+		t((t.s = 3));
+})([
+	function (e, n, t) {
+		"use strict";
+		Object.defineProperty(n, "__esModule", { value: !0 }),
+			(n.isObject = MathJax._.components.global.isObject),
+			(n.combineConfig = MathJax._.components.global.combineConfig),
+			(n.combineDefaults = MathJax._.components.global.combineDefaults),
+			(n.combineWithMathJax = MathJax._.components.global.combineWithMathJax),
+			(n.MathJax = MathJax._.components.global.MathJax);
+	},
+	function (e, n, t) {
+		"use strict";
+		var o =
+			(this && this.__values) ||
+			function (e) {
+				var n = "function" == typeof Symbol && Symbol.iterator,
+					t = n && e[n],
+					o = 0;
+				if (t) return t.call(e);
+				if (e && "number" == typeof e.length)
+					return {
+						next: function () {
+							return (
+								e && o >= e.length && (e = void 0),
+								{ value: e && e[o++], done: !e }
+							);
+						},
+					};
+				throw new TypeError(
+					n ? "Object is not iterable." : "Symbol.iterator is not defined.",
+				);
+			};
+		Object.defineProperty(n, "__esModule", { value: !0 }),
+			(n.NoUndefinedConfiguration = void 0);
+		var r = t(2);
+		n.NoUndefinedConfiguration = r.Configuration.create("noundefined", {
+			fallback: {
+				macro: function (e, n) {
+					var t,
+						r,
+						i = e.create("text", "\\" + n),
+						a = e.options.noundefined || {},
+						u = {};
+					try {
+						for (
+							var f = o(["color", "background", "size"]), c = f.next();
+							!c.done;
+							c = f.next()
+						) {
+							var l = c.value;
+							a[l] && (u["math" + l] = a[l]);
+						}
+					} catch (e) {
+						t = { error: e };
+					} finally {
+						try {
+							c && !c.done && (r = f.return) && r.call(f);
+						} finally {
+							if (t) throw t.error;
+						}
+					}
+					e.Push(e.create("node", "mtext", [], u, i));
+				},
+			},
+			options: { noundefined: { color: "red", background: "", size: "" } },
+			priority: 3,
+		});
+	},
+	function (e, n, t) {
+		"use strict";
+		Object.defineProperty(n, "__esModule", { value: !0 }),
+			(n.Configuration = MathJax._.input.tex.Configuration.Configuration),
+			(n.ConfigurationHandler =
+				MathJax._.input.tex.Configuration.ConfigurationHandler),
+			(n.ParserConfiguration =
+				MathJax._.input.tex.Configuration.ParserConfiguration);
+	},
+	function (e, n, t) {
+		"use strict";
+		t.r(n);
+		var o = t(0),
+			r = t(1);
+		Object(o.combineWithMathJax)({
+			_: { input: { tex: { noundefined: { NoUndefinedConfiguration: r } } } },
+		});
+	},
+]);

assets/bower_components/MathJax/es5/input/tex/extensions/require.js

@@ -0,0 +1,302 @@
+!(function (e) {
+	var t = {};
+	function a(r) {
+		if (t[r]) return t[r].exports;
+		var o = (t[r] = { i: r, l: !1, exports: {} });
+		return e[r].call(o.exports, o, o.exports, a), (o.l = !0), o.exports;
+	}
+	(a.m = e),
+		(a.c = t),
+		(a.d = function (e, t, r) {
+			a.o(e, t) || Object.defineProperty(e, t, { enumerable: !0, get: r });
+		}),
+		(a.r = function (e) {
+			"undefined" != typeof Symbol &&
+				Symbol.toStringTag &&
+				Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }),
+				Object.defineProperty(e, "__esModule", { value: !0 });
+		}),
+		(a.t = function (e, t) {
+			if ((1 & t && (e = a(e)), 8 & t)) return e;
+			if (4 & t && "object" == typeof e && e && e.__esModule) return e;
+			var r = Object.create(null);
+			if (
+				(a.r(r),
+				Object.defineProperty(r, "default", { enumerable: !0, value: e }),
+				2 & t && "string" != typeof e)
+			)
+				for (var o in e)
+					a.d(
+						r,
+						o,
+						function (t) {
+							return e[t];
+						}.bind(null, o),
+					);
+			return r;
+		}),
+		(a.n = function (e) {
+			var t =
+				e && e.__esModule
+					? function () {
+							return e.default;
+						}
+					: function () {
+							return e;
+						};
+			return a.d(t, "a", t), t;
+		}),
+		(a.o = function (e, t) {
+			return Object.prototype.hasOwnProperty.call(e, t);
+		}),
+		(a.p = ""),
+		a((a.s = 9));
+})([
+	function (e, t, a) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.isObject = MathJax._.components.global.isObject),
+			(t.combineConfig = MathJax._.components.global.combineConfig),
+			(t.combineDefaults = MathJax._.components.global.combineDefaults),
+			(t.combineWithMathJax = MathJax._.components.global.combineWithMathJax),
+			(t.MathJax = MathJax._.components.global.MathJax);
+	},
+	function (e, t, a) {
+		"use strict";
+		var r =
+				(this && this.__values) ||
+				function (e) {
+					var t = "function" == typeof Symbol && Symbol.iterator,
+						a = t && e[t],
+						r = 0;
+					if (a) return a.call(e);
+					if (e && "number" == typeof e.length)
+						return {
+							next: function () {
+								return (
+									e && r >= e.length && (e = void 0),
+									{ value: e && e[r++], done: !e }
+								);
+							},
+						};
+					throw new TypeError(
+						t ? "Object is not iterable." : "Symbol.iterator is not defined.",
+					);
+				},
+			o =
+				(this && this.__read) ||
+				function (e, t) {
+					var a = "function" == typeof Symbol && e[Symbol.iterator];
+					if (!a) return e;
+					var r,
+						o,
+						n = a.call(e),
+						i = [];
+					try {
+						for (; (void 0 === t || t-- > 0) && !(r = n.next()).done; )
+							i.push(r.value);
+					} catch (e) {
+						o = { error: e };
+					} finally {
+						try {
+							r && !r.done && (a = n.return) && a.call(n);
+						} finally {
+							if (o) throw o.error;
+						}
+					}
+					return i;
+				},
+			n =
+				(this && this.__spread) ||
+				function () {
+					for (var e = [], t = 0; t < arguments.length; t++)
+						e = e.concat(o(arguments[t]));
+					return e;
+				};
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.RequireConfiguration =
+				t.options =
+				t.RequireMethods =
+				t.RequireLoad =
+					void 0);
+		var i = a(2),
+			u = a(3),
+			s = a(4),
+			p = a(0),
+			l = a(5),
+			c = a(6),
+			f = a(7),
+			d = a(8),
+			x = p.MathJax.config;
+		function h(e, t) {
+			var a,
+				o = e.parseOptions.options.require,
+				n = e.parseOptions.packageData.get("require").required,
+				u = t.substr(o.prefix.length);
+			if (n.indexOf(u) < 0) {
+				n.push(u),
+					(function (e, t) {
+						var a, o;
+						void 0 === t && (t = []);
+						var n = e.parseOptions.options.require.prefix;
+						try {
+							for (var i = r(t), u = i.next(); !u.done; u = i.next()) {
+								var s = u.value;
+								s.substr(0, n.length) === n && h(e, s);
+							}
+						} catch (e) {
+							a = { error: e };
+						} finally {
+							try {
+								u && !u.done && (o = i.return) && o.call(i);
+							} finally {
+								if (a) throw a.error;
+							}
+						}
+					})(e, c.CONFIG.dependencies[t]);
+				var s = i.ConfigurationHandler.get(u);
+				if (s) {
+					var p = x[t] || {};
+					s.options &&
+						1 === Object.keys(s.options).length &&
+						s.options[u] &&
+						(((a = {})[u] = p), (p = a)),
+						e.configuration.add(s, e, p);
+					var l = e.parseOptions.packageData.get("require").configured;
+					s.preprocessors.length &&
+						!l.has(u) &&
+						(l.set(u, !0), f.mathjax.retryAfter(Promise.resolve()));
+				}
+			}
+		}
+		function M(e, t) {
+			var a = e.options.require,
+				r = a.allow,
+				o = ("[" === t.substr(0, 1) ? "" : a.prefix) + t;
+			if (
+				!(r.hasOwnProperty(o)
+					? r[o]
+					: r.hasOwnProperty(t)
+						? r[t]
+						: a.defaultAllow)
+			)
+				throw new s.default(
+					"BadRequire",
+					'Extension "%1" is now allowed to be loaded',
+					o,
+				);
+			l.Package.packages.has(o)
+				? h(e.configuration.packageData.get("require").jax, o)
+				: f.mathjax.retryAfter(c.Loader.load(o));
+		}
+		(t.RequireLoad = M),
+			(t.RequireMethods = {
+				Require: function (e, t) {
+					var a = e.GetArgument(t);
+					if (a.match(/[^_a-zA-Z0-9]/) || "" === a)
+						throw new s.default(
+							"BadPackageName",
+							"Argument for %1 is not a valid package name",
+							t,
+						);
+					M(e, a);
+				},
+			}),
+			(t.options = {
+				require: {
+					allow: d.expandable({ base: !1, "all-packages": !1 }),
+					defaultAllow: !0,
+					prefix: "tex",
+				},
+			}),
+			new u.CommandMap("require", { require: "Require" }, t.RequireMethods),
+			(t.RequireConfiguration = i.Configuration.create("require", {
+				handler: { macro: ["require"] },
+				config: function (e, t) {
+					t.parseOptions.packageData.set("require", {
+						jax: t,
+						required: n(t.options.packages),
+						configured: new Map(),
+					});
+					var a = t.parseOptions.options.require,
+						r = a.prefix;
+					if (r.match(/[^_a-zA-Z0-9]/))
+						throw Error("Illegal characters used in \\require prefix");
+					c.CONFIG.paths[r] ||
+						(c.CONFIG.paths[r] = "[mathjax]/input/tex/extensions"),
+						(a.prefix = "[" + r + "]/");
+				},
+				options: t.options,
+			}));
+	},
+	function (e, t, a) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.Configuration = MathJax._.input.tex.Configuration.Configuration),
+			(t.ConfigurationHandler =
+				MathJax._.input.tex.Configuration.ConfigurationHandler),
+			(t.ParserConfiguration =
+				MathJax._.input.tex.Configuration.ParserConfiguration);
+	},
+	function (e, t, a) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.AbstractSymbolMap = MathJax._.input.tex.SymbolMap.AbstractSymbolMap),
+			(t.RegExpMap = MathJax._.input.tex.SymbolMap.RegExpMap),
+			(t.AbstractParseMap = MathJax._.input.tex.SymbolMap.AbstractParseMap),
+			(t.CharacterMap = MathJax._.input.tex.SymbolMap.CharacterMap),
+			(t.DelimiterMap = MathJax._.input.tex.SymbolMap.DelimiterMap),
+			(t.MacroMap = MathJax._.input.tex.SymbolMap.MacroMap),
+			(t.CommandMap = MathJax._.input.tex.SymbolMap.CommandMap),
+			(t.EnvironmentMap = MathJax._.input.tex.SymbolMap.EnvironmentMap);
+	},
+	function (e, t, a) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.default = MathJax._.input.tex.TexError.default);
+	},
+	function (e, t, a) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.PackageError = MathJax._.components.package.PackageError),
+			(t.Package = MathJax._.components.package.Package);
+	},
+	function (e, t, a) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.Loader = MathJax._.components.loader.Loader),
+			(t.MathJax = MathJax._.components.loader.MathJax),
+			(t.CONFIG = MathJax._.components.loader.CONFIG);
+	},
+	function (e, t, a) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.mathjax = MathJax._.mathjax.mathjax);
+	},
+	function (e, t, a) {
+		"use strict";
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.APPEND = MathJax._.util.Options.APPEND),
+			(t.REMOVE = MathJax._.util.Options.REMOVE),
+			(t.Expandable = MathJax._.util.Options.Expandable),
+			(t.expandable = MathJax._.util.Options.expandable),
+			(t.makeArray = MathJax._.util.Options.makeArray),
+			(t.keys = MathJax._.util.Options.keys),
+			(t.copy = MathJax._.util.Options.copy),
+			(t.insert = MathJax._.util.Options.insert),
+			(t.defaultOptions = MathJax._.util.Options.defaultOptions),
+			(t.userOptions = MathJax._.util.Options.userOptions),
+			(t.selectOptions = MathJax._.util.Options.selectOptions),
+			(t.selectOptionsFromKeys = MathJax._.util.Options.selectOptionsFromKeys),
+			(t.separateOptions = MathJax._.util.Options.separateOptions);
+	},
+	function (e, t, a) {
+		"use strict";
+		a.r(t);
+		var r = a(0),
+			o = a(1);
+		Object(r.combineWithMathJax)({
+			_: { input: { tex: { require: { RequireConfiguration: o } } } },
+		});
+	},
+]);

assets/bower_components/MathJax/es5/input/tex/extensions/tagFormat.js

@@ -0,0 +1,202 @@
+!(function (t) {
+	var n = {};
+	function o(e) {
+		if (n[e]) return n[e].exports;
+		var a = (n[e] = { i: e, l: !1, exports: {} });
+		return t[e].call(a.exports, a, a.exports, o), (a.l = !0), a.exports;
+	}
+	(o.m = t),
+		(o.c = n),
+		(o.d = function (t, n, e) {
+			o.o(t, n) || Object.defineProperty(t, n, { enumerable: !0, get: e });
+		}),
+		(o.r = function (t) {
+			"undefined" != typeof Symbol &&
+				Symbol.toStringTag &&
+				Object.defineProperty(t, Symbol.toStringTag, { value: "Module" }),
+				Object.defineProperty(t, "__esModule", { value: !0 });
+		}),
+		(o.t = function (t, n) {
+			if ((1 & n && (t = o(t)), 8 & n)) return t;
+			if (4 & n && "object" == typeof t && t && t.__esModule) return t;
+			var e = Object.create(null);
+			if (
+				(o.r(e),
+				Object.defineProperty(e, "default", { enumerable: !0, value: t }),
+				2 & n && "string" != typeof t)
+			)
+				for (var a in t)
+					o.d(
+						e,
+						a,
+						function (n) {
+							return t[n];
+						}.bind(null, a),
+					);
+			return e;
+		}),
+		(o.n = function (t) {
+			var n =
+				t && t.__esModule
+					? function () {
+							return t.default;
+						}
+					: function () {
+							return t;
+						};
+			return o.d(n, "a", n), n;
+		}),
+		(o.o = function (t, n) {
+			return Object.prototype.hasOwnProperty.call(t, n);
+		}),
+		(o.p = ""),
+		o((o.s = 4));
+})([
+	function (t, n, o) {
+		"use strict";
+		Object.defineProperty(n, "__esModule", { value: !0 }),
+			(n.isObject = MathJax._.components.global.isObject),
+			(n.combineConfig = MathJax._.components.global.combineConfig),
+			(n.combineDefaults = MathJax._.components.global.combineDefaults),
+			(n.combineWithMathJax = MathJax._.components.global.combineWithMathJax),
+			(n.MathJax = MathJax._.components.global.MathJax);
+	},
+	function (t, n, o) {
+		"use strict";
+		var e,
+			a =
+				(this && this.__extends) ||
+				((e = function (t, n) {
+					return (e =
+						Object.setPrototypeOf ||
+						({ __proto__: [] } instanceof Array &&
+							function (t, n) {
+								t.__proto__ = n;
+							}) ||
+						function (t, n) {
+							for (var o in n) n.hasOwnProperty(o) && (t[o] = n[o]);
+						})(t, n);
+				}),
+				function (t, n) {
+					function o() {
+						this.constructor = t;
+					}
+					e(t, n),
+						(t.prototype =
+							null === n
+								? Object.create(n)
+								: ((o.prototype = n.prototype), new o()));
+				});
+		Object.defineProperty(n, "__esModule", { value: !0 }),
+			(n.TagFormatConfiguration = n.tagformatConfig = void 0);
+		var r = o(2),
+			i = o(3),
+			u = 0;
+		function s(t, n) {
+			var o = n.parseOptions.options.tags;
+			"base" !== o &&
+				t.tags.hasOwnProperty(o) &&
+				i.TagsFactory.add(o, t.tags[o]);
+			var e = (function (t) {
+					function o() {
+						return (null !== t && t.apply(this, arguments)) || this;
+					}
+					return (
+						a(o, t),
+						(o.prototype.formatNumber = function (t) {
+							return n.parseOptions.options.tagformat.number(t);
+						}),
+						(o.prototype.formatTag = function (t) {
+							return n.parseOptions.options.tagformat.tag(t);
+						}),
+						(o.prototype.formatId = function (t) {
+							return n.parseOptions.options.tagformat.id(t);
+						}),
+						(o.prototype.formatUrl = function (t, o) {
+							return n.parseOptions.options.tagformat.url(t, o);
+						}),
+						o
+					);
+				})(i.TagsFactory.create(n.parseOptions.options.tags).constructor),
+				r = "configTags-" + ++u;
+			i.TagsFactory.add(r, e), (n.parseOptions.options.tags = r);
+		}
+		(n.tagformatConfig = s),
+			(n.TagFormatConfiguration = r.Configuration.create("tagformat", {
+				config: [s, 10],
+				options: {
+					tagformat: {
+						number: function (t) {
+							return t.toString();
+						},
+						tag: function (t) {
+							return "(" + t + ")";
+						},
+						id: function (t) {
+							return "mjx-eqn-" + t.replace(/\s/g, "_");
+						},
+						url: function (t, n) {
+							return n + "#" + encodeURIComponent(t);
+						},
+					},
+				},
+			}));
+	},
+	function (t, n, o) {
+		"use strict";
+		Object.defineProperty(n, "__esModule", { value: !0 }),
+			(n.Configuration = MathJax._.input.tex.Configuration.Configuration),
+			(n.ConfigurationHandler =
+				MathJax._.input.tex.Configuration.ConfigurationHandler),
+			(n.ParserConfiguration =
+				MathJax._.input.tex.Configuration.ParserConfiguration);
+	},
+	function (t, n, o) {
+		"use strict";
+		Object.defineProperty(n, "__esModule", { value: !0 }),
+			(n.Label = MathJax._.input.tex.Tags.Label),
+			(n.TagInfo = MathJax._.input.tex.Tags.TagInfo),
+			(n.AbstractTags = MathJax._.input.tex.Tags.AbstractTags),
+			(n.NoTags = MathJax._.input.tex.Tags.NoTags),
+			(n.AllTags = MathJax._.input.tex.Tags.AllTags),
+			(n.TagsFactory = MathJax._.input.tex.Tags.TagsFactory);
+	},
+	function (t, n, o) {
+		"use strict";
+		o.r(n);
+		var e = o(0),
+			a = o(1);
+		Object(e.combineWithMathJax)({
+			_: { input: { tex: { tagformat: { TagFormatConfiguration: a } } } },
+		}),
+			(function (t, n, o) {
+				var a,
+					r,
+					i,
+					u = MathJax.config.tex;
+				if (u && u.packages) {
+					var s = u.packages,
+						f = s.indexOf(t);
+					f >= 0 && (s[f] = n),
+						o &&
+							u[t] &&
+							(Object(e.combineConfig)(
+								u,
+								((a = {}),
+								(r = n),
+								(i = u[t]),
+								r in a
+									? Object.defineProperty(a, r, {
+											value: i,
+											enumerable: !0,
+											configurable: !0,
+											writable: !0,
+										})
+									: (a[r] = i),
+								a),
+							),
+							delete u[t]);
+				}
+			})("tagFormat", "tagformat", !0);
+	},
+]);

assets/bower_components/MathJax/es5/input/tex/extensions/textmacros.js

@@ -0,0 +1,747 @@
+!(function (t) {
+	var e = {};
+	function a(n) {
+		if (e[n]) return e[n].exports;
+		var r = (e[n] = { i: n, l: !1, exports: {} });
+		return t[n].call(r.exports, r, r.exports, a), (r.l = !0), r.exports;
+	}
+	(a.m = t),
+		(a.c = e),
+		(a.d = function (t, e, n) {
+			a.o(t, e) || Object.defineProperty(t, e, { enumerable: !0, get: n });
+		}),
+		(a.r = function (t) {
+			"undefined" != typeof Symbol &&
+				Symbol.toStringTag &&
+				Object.defineProperty(t, Symbol.toStringTag, { value: "Module" }),
+				Object.defineProperty(t, "__esModule", { value: !0 });
+		}),
+		(a.t = function (t, e) {
+			if ((1 & e && (t = a(t)), 8 & e)) return t;
+			if (4 & e && "object" == typeof t && t && t.__esModule) return t;
+			var n = Object.create(null);
+			if (
+				(a.r(n),
+				Object.defineProperty(n, "default", { enumerable: !0, value: t }),
+				2 & e && "string" != typeof t)
+			)
+				for (var r in t)
+					a.d(
+						n,
+						r,
+						function (e) {
+							return t[e];
+						}.bind(null, r),
+					);
+			return n;
+		}),
+		(a.n = function (t) {
+			var e =
+				t && t.__esModule
+					? function () {
+							return t.default;
+						}
+					: function () {
+							return t;
+						};
+			return a.d(e, "a", e), e;
+		}),
+		(a.o = function (t, e) {
+			return Object.prototype.hasOwnProperty.call(t, e);
+		}),
+		(a.p = ""),
+		a((a.s = 18));
+})([
+	function (t, e, a) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.TextMacrosMethods = void 0);
+		var n = a(3),
+			r = a(13),
+			o = a(14);
+		e.TextMacrosMethods = {
+			Comment: function (t, e) {
+				for (; t.i < t.string.length && "\n" !== t.string.charAt(t.i); ) t.i++;
+				t.i++;
+			},
+			Math: function (t, e) {
+				t.saveText();
+				for (var a, r, o = t.i, s = 0; (r = t.GetNext()); )
+					switch (((a = t.i++), r)) {
+						case "\\":
+							")" === t.GetCS() && (r = "\\(");
+						case "$":
+							if (0 === s && e === r) {
+								var i = t.texParser.configuration,
+									c = new n.default(
+										t.string.substr(o, a - o),
+										t.stack.env,
+										i,
+									).mml();
+								return void t.PushMath(c);
+							}
+							break;
+						case "{":
+							s++;
+							break;
+						case "}":
+							0 === s &&
+								t.Error(
+									"ExtraCloseMissingOpen",
+									"Extra close brace or missing open brace",
+								),
+								s--;
+					}
+				t.Error("MathNotTerminated", "Math-mode is not properly terminated");
+			},
+			MathModeOnly: function (t, e) {
+				t.Error("MathModeOnly", "'%1' allowed only in math mode", e);
+			},
+			Misplaced: function (t, e) {
+				t.Error("Misplaced", "'%1' can not be used here", e);
+			},
+			OpenBrace: function (t, e) {
+				var a = t.stack.env;
+				t.envStack.push(a), (t.stack.env = Object.assign({}, a));
+			},
+			CloseBrace: function (t, e) {
+				t.envStack.length
+					? (t.saveText(), (t.stack.env = t.envStack.pop()))
+					: t.Error(
+							"ExtraCloseMissingOpen",
+							"Extra close brace or missing open brace",
+						);
+			},
+			OpenQuote: function (t, e) {
+				t.string.charAt(t.i) === e
+					? ((t.text += "\u201c"), t.i++)
+					: (t.text += "\u2018");
+			},
+			CloseQuote: function (t, e) {
+				t.string.charAt(t.i) === e
+					? ((t.text += "\u201d"), t.i++)
+					: (t.text += "\u2019");
+			},
+			Tilde: function (t, e) {
+				t.text += "\xa0";
+			},
+			Space: function (t, e) {
+				for (t.text += " "; t.GetNext().match(/\s/); ) t.i++;
+			},
+			SelfQuote: function (t, e) {
+				t.text += e.substr(1);
+			},
+			Insert: function (t, e, a) {
+				t.text += a;
+			},
+			Accent: function (t, e, a) {
+				var n = t.ParseArg(name),
+					r = t.create("token", "mo", {}, a);
+				t.addAttributes(r), t.Push(t.create("node", "mover", [n, r]));
+			},
+			Emph: function (t, e) {
+				var a =
+					"-tex-mathit" === t.stack.env.mathvariant ? "normal" : "-tex-mathit";
+				t.Push(t.ParseTextArg(e, { mathvariant: a }));
+			},
+			SetFont: function (t, e, a) {
+				t.saveText(), (t.stack.env.mathvariant = a);
+			},
+			SetSize: function (t, e, a) {
+				t.saveText(), (t.stack.env.mathsize = a);
+			},
+			CheckAutoload: function (t, e) {
+				var a = t.configuration.packageData.get("autoload"),
+					n = t.texParser;
+				e = e.slice(1);
+				var o = n.lookup("macro", e);
+				if (!o || (a && o._func === a.Autoload)) {
+					if ((n.parse("macro", [n, e]), !o)) return;
+					r.retryAfter(Promise.resolve());
+				}
+				n.parse("macro", [t, e]);
+			},
+			Macro: o.default.Macro,
+			Spacer: o.default.Spacer,
+			Hskip: o.default.Hskip,
+			rule: o.default.rule,
+			Rule: o.default.Rule,
+			HandleRef: o.default.HandleRef,
+		};
+	},
+	function (t, e, a) {
+		"use strict";
+		var n,
+			r =
+				(this && this.__extends) ||
+				((n = function (t, e) {
+					return (n =
+						Object.setPrototypeOf ||
+						({ __proto__: [] } instanceof Array &&
+							function (t, e) {
+								t.__proto__ = e;
+							}) ||
+						function (t, e) {
+							for (var a in e) e.hasOwnProperty(a) && (t[a] = e[a]);
+						})(t, e);
+				}),
+				function (t, e) {
+					function a() {
+						this.constructor = t;
+					}
+					n(t, e),
+						(t.prototype =
+							null === e
+								? Object.create(e)
+								: ((a.prototype = e.prototype), new a()));
+				}),
+			o =
+				(this && this.__values) ||
+				function (t) {
+					var e = "function" == typeof Symbol && Symbol.iterator,
+						a = e && t[e],
+						n = 0;
+					if (a) return a.call(t);
+					if (t && "number" == typeof t.length)
+						return {
+							next: function () {
+								return (
+									t && n >= t.length && (t = void 0),
+									{ value: t && t[n++], done: !t }
+								);
+							},
+						};
+					throw new TypeError(
+						e ? "Object is not iterable." : "Symbol.iterator is not defined.",
+					);
+				},
+			s =
+				(this && this.__read) ||
+				function (t, e) {
+					var a = "function" == typeof Symbol && t[Symbol.iterator];
+					if (!a) return t;
+					var n,
+						r,
+						o = a.call(t),
+						s = [];
+					try {
+						for (; (void 0 === e || e-- > 0) && !(n = o.next()).done; )
+							s.push(n.value);
+					} catch (t) {
+						r = { error: t };
+					} finally {
+						try {
+							n && !n.done && (a = o.return) && a.call(o);
+						} finally {
+							if (r) throw r.error;
+						}
+					}
+					return s;
+				},
+			i =
+				(this && this.__spread) ||
+				function () {
+					for (var t = [], e = 0; e < arguments.length; e++)
+						t = t.concat(s(arguments[e]));
+					return t;
+				};
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.TextParser = void 0);
+		var c = a(3),
+			u = a(9),
+			l = a(10),
+			p = a(11),
+			m = a(12),
+			h = a(2),
+			f = (function (t) {
+				function e(e, a, n, r) {
+					var o = t.call(this, e, a, n) || this;
+					return (o.level = r), o;
+				}
+				return (
+					r(e, t),
+					Object.defineProperty(e.prototype, "texParser", {
+						get: function () {
+							return this.configuration.packageData.get("textmacros").texParser;
+						},
+						enumerable: !1,
+						configurable: !0,
+					}),
+					Object.defineProperty(e.prototype, "tags", {
+						get: function () {
+							return this.texParser.tags;
+						},
+						enumerable: !1,
+						configurable: !0,
+					}),
+					(e.prototype.mml = function () {
+						return null != this.level
+							? this.create("node", "mstyle", this.nodes, {
+									displaystyle: !1,
+									scriptlevel: this.level,
+								})
+							: 1 === this.nodes.length
+								? this.nodes[0]
+								: this.create("node", "inferredMrow", this.nodes);
+					}),
+					(e.prototype.Parse = function () {
+						(this.text = ""),
+							(this.nodes = []),
+							(this.envStack = []),
+							t.prototype.Parse.call(this);
+					}),
+					(e.prototype.saveText = function () {
+						if (this.text) {
+							var t = this.stack.env.mathvariant,
+								e = l.default.internalText(
+									this,
+									this.text,
+									t ? { mathvariant: t } : {},
+								);
+							(this.text = ""), this.Push(e);
+						}
+					}),
+					(e.prototype.Push = function (e) {
+						if ((this.text && this.saveText(), e instanceof h.StopItem))
+							return t.prototype.Push.call(this, e);
+						e instanceof h.StyleItem
+							? (this.stack.env.mathcolor = this.stack.env.color)
+							: e instanceof p.AbstractMmlNode &&
+								(this.addAttributes(e), this.nodes.push(e));
+					}),
+					(e.prototype.PushMath = function (t) {
+						var e,
+							a,
+							n = this.stack.env;
+						try {
+							for (
+								var r = o(["mathsize", "mathcolor"]), s = r.next();
+								!s.done;
+								s = r.next()
+							) {
+								var i = s.value;
+								n[i] &&
+									!t.attributes.getExplicit(i) &&
+									(t.isToken ||
+										t.isKind("mstyle") ||
+										(t = this.create("node", "mstyle", [t])),
+									m.default.setAttribute(t, i, n[i]));
+							}
+						} catch (t) {
+							e = { error: t };
+						} finally {
+							try {
+								s && !s.done && (a = r.return) && a.call(r);
+							} finally {
+								if (e) throw e.error;
+							}
+						}
+						t.isKind("inferredMrow") &&
+							(t = this.create("node", "mrow", t.childNodes)),
+							this.nodes.push(t);
+					}),
+					(e.prototype.addAttributes = function (t) {
+						var e,
+							a,
+							n = this.stack.env;
+						if (t.isToken)
+							try {
+								for (
+									var r = o(["mathsize", "mathcolor", "mathvariant"]),
+										s = r.next();
+									!s.done;
+									s = r.next()
+								) {
+									var i = s.value;
+									n[i] &&
+										!t.attributes.getExplicit(i) &&
+										m.default.setAttribute(t, i, n[i]);
+								}
+							} catch (t) {
+								e = { error: t };
+							} finally {
+								try {
+									s && !s.done && (a = r.return) && a.call(r);
+								} finally {
+									if (e) throw e.error;
+								}
+							}
+					}),
+					(e.prototype.ParseTextArg = function (t, a) {
+						return new e(
+							this.GetArgument(t),
+							(a = Object.assign(Object.assign({}, this.stack.env), a)),
+							this.configuration,
+						).mml();
+					}),
+					(e.prototype.ParseArg = function (t) {
+						return new e(
+							this.GetArgument(t),
+							this.stack.env,
+							this.configuration,
+						).mml();
+					}),
+					(e.prototype.Error = function (t, e) {
+						for (var a = [], n = 2; n < arguments.length; n++)
+							a[n - 2] = arguments[n];
+						throw new (u.default.bind.apply(u.default, i([void 0, t, e], a)))();
+					}),
+					e
+				);
+			})(c.default);
+		e.TextParser = f;
+	},
+	function (t, e, a) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.StartItem = MathJax._.input.tex.base.BaseItems.StartItem),
+			(e.StopItem = MathJax._.input.tex.base.BaseItems.StopItem),
+			(e.OpenItem = MathJax._.input.tex.base.BaseItems.OpenItem),
+			(e.CloseItem = MathJax._.input.tex.base.BaseItems.CloseItem),
+			(e.PrimeItem = MathJax._.input.tex.base.BaseItems.PrimeItem),
+			(e.SubsupItem = MathJax._.input.tex.base.BaseItems.SubsupItem),
+			(e.OverItem = MathJax._.input.tex.base.BaseItems.OverItem),
+			(e.LeftItem = MathJax._.input.tex.base.BaseItems.LeftItem),
+			(e.RightItem = MathJax._.input.tex.base.BaseItems.RightItem),
+			(e.BeginItem = MathJax._.input.tex.base.BaseItems.BeginItem),
+			(e.EndItem = MathJax._.input.tex.base.BaseItems.EndItem),
+			(e.StyleItem = MathJax._.input.tex.base.BaseItems.StyleItem),
+			(e.PositionItem = MathJax._.input.tex.base.BaseItems.PositionItem),
+			(e.CellItem = MathJax._.input.tex.base.BaseItems.CellItem),
+			(e.MmlItem = MathJax._.input.tex.base.BaseItems.MmlItem),
+			(e.FnItem = MathJax._.input.tex.base.BaseItems.FnItem),
+			(e.NotItem = MathJax._.input.tex.base.BaseItems.NotItem),
+			(e.DotsItem = MathJax._.input.tex.base.BaseItems.DotsItem),
+			(e.ArrayItem = MathJax._.input.tex.base.BaseItems.ArrayItem),
+			(e.EqnArrayItem = MathJax._.input.tex.base.BaseItems.EqnArrayItem),
+			(e.EquationItem = MathJax._.input.tex.base.BaseItems.EquationItem);
+	},
+	function (t, e, a) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.default = MathJax._.input.tex.TexParser.default);
+	},
+	function (t, e, a) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.isObject = MathJax._.components.global.isObject),
+			(e.combineConfig = MathJax._.components.global.combineConfig),
+			(e.combineDefaults = MathJax._.components.global.combineDefaults),
+			(e.combineWithMathJax = MathJax._.components.global.combineWithMathJax),
+			(e.MathJax = MathJax._.components.global.MathJax);
+	},
+	function (t, e, a) {
+		"use strict";
+		var n;
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.textBase = void 0);
+		var r = a(6),
+			o = a(7),
+			s = a(8),
+			i = a(2),
+			c = a(1),
+			u = a(0);
+		function l(t, e, a, n) {
+			var r = t.configuration.packageData.get("textmacros");
+			return (
+				t instanceof c.TextParser || (r.texParser = t),
+				[
+					new c.TextParser(
+						e,
+						n ? { mathvariant: n } : {},
+						r.parseOptions,
+						a,
+					).mml(),
+				]
+			);
+		}
+		a(15),
+			(e.textBase = r.Configuration.local({
+				handler: {
+					character: ["command", "text-special"],
+					macro: ["text-macros"],
+				},
+				fallback: {
+					character: function (t, e) {
+						t.text += e;
+					},
+					macro: function (t, e) {
+						var a = t.texParser,
+							n = a.lookup("macro", e);
+						n &&
+							n._func !== u.TextMacrosMethods.Macro &&
+							t.Error(
+								"MathMacro",
+								"%1 is only supported in math mode",
+								"\\" + e,
+							),
+							a.parse("macro", [n ? t : a, e]);
+					},
+				},
+				items:
+					((n = {}),
+					(n[i.StartItem.prototype.kind] = i.StartItem),
+					(n[i.StopItem.prototype.kind] = i.StopItem),
+					(n[i.MmlItem.prototype.kind] = i.MmlItem),
+					(n[i.StyleItem.prototype.kind] = i.StyleItem),
+					n),
+			})),
+			r.Configuration.create("textmacros", {
+				config: function (t, a) {
+					var n = new r.ParserConfiguration([]);
+					n.append(e.textBase), n.init();
+					var i = new o.default(n, []);
+					(i.options = a.parseOptions.options),
+						n.config(a),
+						s.TagsFactory.addTags(n.tags),
+						(i.tags = s.TagsFactory.getDefault()),
+						(i.tags.configuration = i),
+						(i.packageData = a.parseOptions.packageData),
+						i.packageData.set("textmacros", {
+							parseOptions: i,
+							jax: a,
+							texParser: null,
+						}),
+						(i.options.internalMath = l);
+				},
+				preprocessors: [
+					function (t) {
+						var e = t.data.packageData.get("textmacros");
+						e.parseOptions.nodeFactory.setMmlFactory(e.jax.mmlFactory);
+					},
+				],
+			});
+	},
+	function (t, e, a) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.Configuration = MathJax._.input.tex.Configuration.Configuration),
+			(e.ConfigurationHandler =
+				MathJax._.input.tex.Configuration.ConfigurationHandler),
+			(e.ParserConfiguration =
+				MathJax._.input.tex.Configuration.ParserConfiguration);
+	},
+	function (t, e, a) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.default = MathJax._.input.tex.ParseOptions.default);
+	},
+	function (t, e, a) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.Label = MathJax._.input.tex.Tags.Label),
+			(e.TagInfo = MathJax._.input.tex.Tags.TagInfo),
+			(e.AbstractTags = MathJax._.input.tex.Tags.AbstractTags),
+			(e.NoTags = MathJax._.input.tex.Tags.NoTags),
+			(e.AllTags = MathJax._.input.tex.Tags.AllTags),
+			(e.TagsFactory = MathJax._.input.tex.Tags.TagsFactory);
+	},
+	function (t, e, a) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.default = MathJax._.input.tex.TexError.default);
+	},
+	function (t, e, a) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.default = MathJax._.input.tex.ParseUtil.default);
+	},
+	function (t, e, a) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.TEXCLASS = MathJax._.core.MmlTree.MmlNode.TEXCLASS),
+			(e.TEXCLASSNAMES = MathJax._.core.MmlTree.MmlNode.TEXCLASSNAMES),
+			(e.indentAttributes = MathJax._.core.MmlTree.MmlNode.indentAttributes),
+			(e.AbstractMmlNode = MathJax._.core.MmlTree.MmlNode.AbstractMmlNode),
+			(e.AbstractMmlTokenNode =
+				MathJax._.core.MmlTree.MmlNode.AbstractMmlTokenNode),
+			(e.AbstractMmlLayoutNode =
+				MathJax._.core.MmlTree.MmlNode.AbstractMmlLayoutNode),
+			(e.AbstractMmlBaseNode =
+				MathJax._.core.MmlTree.MmlNode.AbstractMmlBaseNode),
+			(e.AbstractMmlEmptyNode =
+				MathJax._.core.MmlTree.MmlNode.AbstractMmlEmptyNode),
+			(e.TextNode = MathJax._.core.MmlTree.MmlNode.TextNode),
+			(e.XMLNode = MathJax._.core.MmlTree.MmlNode.XMLNode);
+	},
+	function (t, e, a) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.default = MathJax._.input.tex.NodeUtil.default);
+	},
+	function (t, e, a) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.handleRetriesFor = MathJax._.util.Retries.handleRetriesFor),
+			(e.retryAfter = MathJax._.util.Retries.retryAfter);
+	},
+	function (t, e, a) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.default = MathJax._.input.tex.base.BaseMethods.default);
+	},
+	function (t, e, a) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 });
+		var n = a(16),
+			r = a(17),
+			o = a(0);
+		new n.MacroMap(
+			"text-special",
+			{
+				$: "Math",
+				"%": "Comment",
+				"^": "MathModeOnly",
+				_: "MathModeOnly",
+				"&": "Misplaced",
+				"#": "Misplaced",
+				"~": "Tilde",
+				" ": "Space",
+				"\t": "Space",
+				"\r": "Space",
+				"\n": "Space",
+				"\xa0": "Tilde",
+				"{": "OpenBrace",
+				"}": "CloseBrace",
+				"`": "OpenQuote",
+				"'": "CloseQuote",
+			},
+			o.TextMacrosMethods,
+		),
+			new n.CommandMap(
+				"text-macros",
+				{
+					"(": "Math",
+					$: "SelfQuote",
+					_: "SelfQuote",
+					"%": "SelfQuote",
+					"{": "SelfQuote",
+					"}": "SelfQuote",
+					" ": "SelfQuote",
+					"&": "SelfQuote",
+					"#": "SelfQuote",
+					"\\": "SelfQuote",
+					"'": ["Accent", "\xb4"],
+					"\u2019": ["Accent", "\xb4"],
+					"`": ["Accent", "`"],
+					"\u2018": ["Accent", "`"],
+					"^": ["Accent", "^"],
+					'"': ["Accent", "\xa8"],
+					"~": ["Accent", "~"],
+					"=": ["Accent", "\xaf"],
+					".": ["Accent", "\u02d9"],
+					u: ["Accent", "\u02d8"],
+					v: ["Accent", "\u02c7"],
+					emph: "Emph",
+					rm: ["SetFont", r.TexConstant.Variant.NORMAL],
+					mit: ["SetFont", r.TexConstant.Variant.ITALIC],
+					oldstyle: ["SetFont", r.TexConstant.Variant.OLDSTYLE],
+					cal: ["SetFont", r.TexConstant.Variant.CALLIGRAPHIC],
+					it: ["SetFont", "-tex-mathit"],
+					bf: ["SetFont", r.TexConstant.Variant.BOLD],
+					bbFont: ["SetFont", r.TexConstant.Variant.DOUBLESTRUCK],
+					scr: ["SetFont", r.TexConstant.Variant.SCRIPT],
+					frak: ["SetFont", r.TexConstant.Variant.FRAKTUR],
+					sf: ["SetFont", r.TexConstant.Variant.SANSSERIF],
+					tt: ["SetFont", r.TexConstant.Variant.MONOSPACE],
+					tiny: ["SetSize", 0.5],
+					Tiny: ["SetSize", 0.6],
+					scriptsize: ["SetSize", 0.7],
+					small: ["SetSize", 0.85],
+					normalsize: ["SetSize", 1],
+					large: ["SetSize", 1.2],
+					Large: ["SetSize", 1.44],
+					LARGE: ["SetSize", 1.73],
+					huge: ["SetSize", 2.07],
+					Huge: ["SetSize", 2.49],
+					mathcal: "MathModeOnly",
+					mathscr: "MathModeOnly",
+					mathrm: "MathModeOnly",
+					mathbf: "MathModeOnly",
+					mathbb: "MathModeOnly",
+					mathit: "MathModeOnly",
+					mathfrak: "MathModeOnly",
+					mathsf: "MathModeOnly",
+					mathtt: "MathModeOnly",
+					Bbb: ["Macro", "{\\bbFont #1}", 1],
+					textrm: ["Macro", "{\\rm #1}", 1],
+					textit: ["Macro", "{\\it #1}", 1],
+					textbf: ["Macro", "{\\bf #1}", 1],
+					textsf: ["Macro", "{\\sf #1}", 1],
+					texttt: ["Macro", "{\\tt #1}", 1],
+					dagger: ["Insert", "\u2020"],
+					ddagger: ["Insert", "\u2021"],
+					S: ["Insert", "\xa7"],
+					",": ["Spacer", r.TexConstant.Length.THINMATHSPACE],
+					":": ["Spacer", r.TexConstant.Length.MEDIUMMATHSPACE],
+					">": ["Spacer", r.TexConstant.Length.MEDIUMMATHSPACE],
+					";": ["Spacer", r.TexConstant.Length.THICKMATHSPACE],
+					"!": ["Spacer", r.TexConstant.Length.NEGATIVETHINMATHSPACE],
+					enspace: ["Spacer", ".5em"],
+					quad: ["Spacer", "1em"],
+					qquad: ["Spacer", "2em"],
+					thinspace: ["Spacer", r.TexConstant.Length.THINMATHSPACE],
+					negthinspace: ["Spacer", r.TexConstant.Length.NEGATIVETHINMATHSPACE],
+					hskip: "Hskip",
+					hspace: "Hskip",
+					kern: "Hskip",
+					mskip: "Hskip",
+					mspace: "Hskip",
+					mkern: "Hskip",
+					rule: "rule",
+					Rule: ["Rule"],
+					Space: ["Rule", "blank"],
+					color: "CheckAutoload",
+					textcolor: "CheckAutoload",
+					colorbox: "CheckAutoload",
+					fcolorbox: "CheckAutoload",
+					href: "CheckAutoload",
+					style: "CheckAutoload",
+					class: "CheckAutoload",
+					cssId: "CheckAutoload",
+					unicode: "CheckAutoload",
+					ref: ["HandleRef", !1],
+					eqref: ["HandleRef", !0],
+				},
+				o.TextMacrosMethods,
+			);
+	},
+	function (t, e, a) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.AbstractSymbolMap = MathJax._.input.tex.SymbolMap.AbstractSymbolMap),
+			(e.RegExpMap = MathJax._.input.tex.SymbolMap.RegExpMap),
+			(e.AbstractParseMap = MathJax._.input.tex.SymbolMap.AbstractParseMap),
+			(e.CharacterMap = MathJax._.input.tex.SymbolMap.CharacterMap),
+			(e.DelimiterMap = MathJax._.input.tex.SymbolMap.DelimiterMap),
+			(e.MacroMap = MathJax._.input.tex.SymbolMap.MacroMap),
+			(e.CommandMap = MathJax._.input.tex.SymbolMap.CommandMap),
+			(e.EnvironmentMap = MathJax._.input.tex.SymbolMap.EnvironmentMap);
+	},
+	function (t, e, a) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.TexConstant = MathJax._.input.tex.TexConstants.TexConstant);
+	},
+	function (t, e, a) {
+		"use strict";
+		a.r(e);
+		var n = a(4),
+			r = a(5),
+			o = a(0),
+			s = a(1);
+		Object(n.combineWithMathJax)({
+			_: {
+				input: {
+					tex: {
+						textmacros: {
+							TextMacrosConfiguration: r,
+							TextMacrosMethods: o,
+							TextParser: s,
+						},
+					},
+				},
+			},
+		});
+	},
+]);

assets/bower_components/MathJax/es5/input/tex/extensions/unicode.js

@@ -0,0 +1,166 @@
+!(function (t) {
+	var e = {};
+	function a(n) {
+		if (e[n]) return e[n].exports;
+		var o = (e[n] = { i: n, l: !1, exports: {} });
+		return t[n].call(o.exports, o, o.exports, a), (o.l = !0), o.exports;
+	}
+	(a.m = t),
+		(a.c = e),
+		(a.d = function (t, e, n) {
+			a.o(t, e) || Object.defineProperty(t, e, { enumerable: !0, get: n });
+		}),
+		(a.r = function (t) {
+			"undefined" != typeof Symbol &&
+				Symbol.toStringTag &&
+				Object.defineProperty(t, Symbol.toStringTag, { value: "Module" }),
+				Object.defineProperty(t, "__esModule", { value: !0 });
+		}),
+		(a.t = function (t, e) {
+			if ((1 & e && (t = a(t)), 8 & e)) return t;
+			if (4 & e && "object" == typeof t && t && t.__esModule) return t;
+			var n = Object.create(null);
+			if (
+				(a.r(n),
+				Object.defineProperty(n, "default", { enumerable: !0, value: t }),
+				2 & e && "string" != typeof t)
+			)
+				for (var o in t)
+					a.d(
+						n,
+						o,
+						function (e) {
+							return t[e];
+						}.bind(null, o),
+					);
+			return n;
+		}),
+		(a.n = function (t) {
+			var e =
+				t && t.__esModule
+					? function () {
+							return t.default;
+						}
+					: function () {
+							return t;
+						};
+			return a.d(e, "a", e), e;
+		}),
+		(a.o = function (t, e) {
+			return Object.prototype.hasOwnProperty.call(t, e);
+		}),
+		(a.p = ""),
+		a((a.s = 8));
+})([
+	function (t, e, a) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.isObject = MathJax._.components.global.isObject),
+			(e.combineConfig = MathJax._.components.global.combineConfig),
+			(e.combineDefaults = MathJax._.components.global.combineDefaults),
+			(e.combineWithMathJax = MathJax._.components.global.combineWithMathJax),
+			(e.MathJax = MathJax._.components.global.MathJax);
+	},
+	function (t, e, a) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.UnicodeConfiguration = e.UnicodeMethods = void 0);
+		var n = a(2),
+			o = a(3),
+			i = a(4),
+			r = a(5),
+			u = a(6),
+			c = a(7);
+		e.UnicodeMethods = {};
+		var l = {};
+		(e.UnicodeMethods.Unicode = function (t, e) {
+			var a = t.GetBrackets(e),
+				n = null,
+				i = null;
+			a &&
+				(a.replace(/ /g, "").match(/^(\d+(\.\d*)?|\.\d+),(\d+(\.\d*)?|\.\d+)$/)
+					? ((n = a.replace(/ /g, "").split(/,/)), (i = t.GetBrackets(e)))
+					: (i = a));
+			var d = r.default.trimSpaces(t.GetArgument(e)).replace(/^0x/, "x");
+			if (!d.match(/^(x[0-9A-Fa-f]+|[0-9]+)$/))
+				throw new o.default(
+					"BadUnicode",
+					"Argument to \\unicode must be a number",
+				);
+			var p = parseInt(d.match(/^x/) ? "0" + d : d);
+			l[p] ? i || (i = l[p][2]) : (l[p] = [800, 200, i, p]),
+				n &&
+					((l[p][0] = Math.floor(1e3 * parseFloat(n[0]))),
+					(l[p][1] = Math.floor(1e3 * parseFloat(n[1]))));
+			var s = t.stack.env.font,
+				f = {};
+			i
+				? ((l[p][2] = f.fontfamily = i.replace(/'/g, "'")),
+					s &&
+						(s.match(/bold/) && (f.fontweight = "bold"),
+						s.match(/italic|-mathit/) && (f.fontstyle = "italic")))
+				: s && (f.mathvariant = s);
+			var M = t.create("token", "mtext", f, c.numeric(d));
+			u.default.setProperty(M, "unicode", !0), t.Push(M);
+		}),
+			new i.CommandMap("unicode", { unicode: "Unicode" }, e.UnicodeMethods),
+			(e.UnicodeConfiguration = n.Configuration.create("unicode", {
+				handler: { macro: ["unicode"] },
+			}));
+	},
+	function (t, e, a) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.Configuration = MathJax._.input.tex.Configuration.Configuration),
+			(e.ConfigurationHandler =
+				MathJax._.input.tex.Configuration.ConfigurationHandler),
+			(e.ParserConfiguration =
+				MathJax._.input.tex.Configuration.ParserConfiguration);
+	},
+	function (t, e, a) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.default = MathJax._.input.tex.TexError.default);
+	},
+	function (t, e, a) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.AbstractSymbolMap = MathJax._.input.tex.SymbolMap.AbstractSymbolMap),
+			(e.RegExpMap = MathJax._.input.tex.SymbolMap.RegExpMap),
+			(e.AbstractParseMap = MathJax._.input.tex.SymbolMap.AbstractParseMap),
+			(e.CharacterMap = MathJax._.input.tex.SymbolMap.CharacterMap),
+			(e.DelimiterMap = MathJax._.input.tex.SymbolMap.DelimiterMap),
+			(e.MacroMap = MathJax._.input.tex.SymbolMap.MacroMap),
+			(e.CommandMap = MathJax._.input.tex.SymbolMap.CommandMap),
+			(e.EnvironmentMap = MathJax._.input.tex.SymbolMap.EnvironmentMap);
+	},
+	function (t, e, a) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.default = MathJax._.input.tex.ParseUtil.default);
+	},
+	function (t, e, a) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.default = MathJax._.input.tex.NodeUtil.default);
+	},
+	function (t, e, a) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.options = MathJax._.util.Entities.options),
+			(e.entities = MathJax._.util.Entities.entities),
+			(e.add = MathJax._.util.Entities.add),
+			(e.remove = MathJax._.util.Entities.remove),
+			(e.translate = MathJax._.util.Entities.translate),
+			(e.numeric = MathJax._.util.Entities.numeric);
+	},
+	function (t, e, a) {
+		"use strict";
+		a.r(e);
+		var n = a(0),
+			o = a(1);
+		Object(n.combineWithMathJax)({
+			_: { input: { tex: { unicode: { UnicodeConfiguration: o } } } },
+		});
+	},
+]);

assets/bower_components/MathJax/es5/input/tex/extensions/verb.js

@@ -0,0 +1,141 @@
+!(function (t) {
+	var e = {};
+	function n(a) {
+		if (e[a]) return e[a].exports;
+		var r = (e[a] = { i: a, l: !1, exports: {} });
+		return t[a].call(r.exports, r, r.exports, n), (r.l = !0), r.exports;
+	}
+	(n.m = t),
+		(n.c = e),
+		(n.d = function (t, e, a) {
+			n.o(t, e) || Object.defineProperty(t, e, { enumerable: !0, get: a });
+		}),
+		(n.r = function (t) {
+			"undefined" != typeof Symbol &&
+				Symbol.toStringTag &&
+				Object.defineProperty(t, Symbol.toStringTag, { value: "Module" }),
+				Object.defineProperty(t, "__esModule", { value: !0 });
+		}),
+		(n.t = function (t, e) {
+			if ((1 & e && (t = n(t)), 8 & e)) return t;
+			if (4 & e && "object" == typeof t && t && t.__esModule) return t;
+			var a = Object.create(null);
+			if (
+				(n.r(a),
+				Object.defineProperty(a, "default", { enumerable: !0, value: t }),
+				2 & e && "string" != typeof t)
+			)
+				for (var r in t)
+					n.d(
+						a,
+						r,
+						function (e) {
+							return t[e];
+						}.bind(null, r),
+					);
+			return a;
+		}),
+		(n.n = function (t) {
+			var e =
+				t && t.__esModule
+					? function () {
+							return t.default;
+						}
+					: function () {
+							return t;
+						};
+			return n.d(e, "a", e), e;
+		}),
+		(n.o = function (t, e) {
+			return Object.prototype.hasOwnProperty.call(t, e);
+		}),
+		(n.p = ""),
+		n((n.s = 6));
+})([
+	function (t, e, n) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.isObject = MathJax._.components.global.isObject),
+			(e.combineConfig = MathJax._.components.global.combineConfig),
+			(e.combineDefaults = MathJax._.components.global.combineDefaults),
+			(e.combineWithMathJax = MathJax._.components.global.combineWithMathJax),
+			(e.MathJax = MathJax._.components.global.MathJax);
+	},
+	function (t, e, n) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.VerbConfiguration = e.VerbMethods = void 0);
+		var a = n(2),
+			r = n(3),
+			o = n(4),
+			i = n(5);
+		(e.VerbMethods = {}),
+			(e.VerbMethods.Verb = function (t, e) {
+				var n = t.GetNext(),
+					a = ++t.i;
+				if ("" === n)
+					throw new i.default("MissingArgFor", "Missing argument for %1", e);
+				for (; t.i < t.string.length && t.string.charAt(t.i) !== n; ) t.i++;
+				if (t.i === t.string.length)
+					throw new i.default(
+						"NoClosingDelim",
+						"Can't find closing delimiter for %1",
+						t.currentCS,
+					);
+				var o = t.string.slice(a, t.i).replace(/ /g, "\xa0");
+				t.i++,
+					t.Push(
+						t.create(
+							"token",
+							"mtext",
+							{ mathvariant: r.TexConstant.Variant.MONOSPACE },
+							o,
+						),
+					);
+			}),
+			new o.CommandMap("verb", { verb: "Verb" }, e.VerbMethods),
+			(e.VerbConfiguration = a.Configuration.create("verb", {
+				handler: { macro: ["verb"] },
+			}));
+	},
+	function (t, e, n) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.Configuration = MathJax._.input.tex.Configuration.Configuration),
+			(e.ConfigurationHandler =
+				MathJax._.input.tex.Configuration.ConfigurationHandler),
+			(e.ParserConfiguration =
+				MathJax._.input.tex.Configuration.ParserConfiguration);
+	},
+	function (t, e, n) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.TexConstant = MathJax._.input.tex.TexConstants.TexConstant);
+	},
+	function (t, e, n) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.AbstractSymbolMap = MathJax._.input.tex.SymbolMap.AbstractSymbolMap),
+			(e.RegExpMap = MathJax._.input.tex.SymbolMap.RegExpMap),
+			(e.AbstractParseMap = MathJax._.input.tex.SymbolMap.AbstractParseMap),
+			(e.CharacterMap = MathJax._.input.tex.SymbolMap.CharacterMap),
+			(e.DelimiterMap = MathJax._.input.tex.SymbolMap.DelimiterMap),
+			(e.MacroMap = MathJax._.input.tex.SymbolMap.MacroMap),
+			(e.CommandMap = MathJax._.input.tex.SymbolMap.CommandMap),
+			(e.EnvironmentMap = MathJax._.input.tex.SymbolMap.EnvironmentMap);
+	},
+	function (t, e, n) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.default = MathJax._.input.tex.TexError.default);
+	},
+	function (t, e, n) {
+		"use strict";
+		n.r(e);
+		var a = n(0),
+			r = n(1);
+		Object(a.combineWithMathJax)({
+			_: { input: { tex: { verb: { VerbConfiguration: r } } } },
+		});
+	},
+]);