a new start

assets/bower.json

@@ -0,0 +1,12 @@
+{
+	"name": "pivoine-assets",
+	"homepage": "https://pivoine.com/",
+	"author": "Florian Klampfer <mail@qwtel.com> (https://qwtel.com/)",
+	"license": "MIT",
+	"private": true,
+	"dependencies": {
+		"html5shiv": "^3.7.3",
+		"katex": "^0.11.1",
+		"MathJax": "^3.1.2"
+	}
+}

assets/bower_components/MathJax/.bower.json

@@ -0,0 +1,18 @@
+{
+	"name": "MathJax",
+	"main": "./MathJax.js",
+	"homepage": "http://www.mathjax.org/",
+	"ignore": ["**/.*", "node_modules", "components"],
+	"keywords": ["math", "js", "LaTeX", "MathML", "AsciiMath"],
+	"version": "3.1.2",
+	"_release": "3.1.2",
+	"_resolution": {
+		"type": "version",
+		"tag": "3.1.2",
+		"commit": "c8292351190ce249f7143f224dbe7a190c8228fe"
+	},
+	"_source": "https://github.com/mathjax/MathJax.git",
+	"_target": "^3.1.2",
+	"_originalSource": "MathJax",
+	"_direct": true
+}

assets/bower_components/MathJax/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

assets/bower_components/MathJax/bower.json

@@ -0,0 +1,7 @@
+{
+	"name": "MathJax",
+	"main": "./MathJax.js",
+	"homepage": "http://www.mathjax.org/",
+	"ignore": ["**/.*", "node_modules", "components"],
+	"keywords": ["math", "js", "LaTeX", "MathML", "AsciiMath"]
+}

assets/bower_components/MathJax/composer.json

@@ -0,0 +1,14 @@
+{
+	"name": "mathjax/mathjax",
+	"type": "library",
+	"description": "MathJax is an open-source JavaScript display engine for LaTeX, MathML, and AsciiMath notation that works in all modern browsers.",
+	"keywords": ["math", "js", "LaTeX", "MathML", "AsciiMath"],
+	"homepage": "http://www.mathjax.org/",
+	"license": "Apache-2.0",
+	"authors": [
+		{
+			"name": "MathJax Consortium",
+			"homepage": "https://github.com/mathjax"
+		}
+	]
+}

assets/bower_components/MathJax/es5/a11y/assistive-mml.js

@@ -0,0 +1,360 @@
+!(function (t) {
+	var e = {};
+	function i(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, i), (o.l = !0), o.exports;
+	}
+	(i.m = t),
+		(i.c = e),
+		(i.d = function (t, e, n) {
+			i.o(t, e) || Object.defineProperty(t, e, { enumerable: !0, get: n });
+		}),
+		(i.r = function (t) {
+			"undefined" != typeof Symbol &&
+				Symbol.toStringTag &&
+				Object.defineProperty(t, Symbol.toStringTag, { value: "Module" }),
+				Object.defineProperty(t, "__esModule", { value: !0 });
+		}),
+		(i.t = function (t, e) {
+			if ((1 & e && (t = i(t)), 8 & e)) return t;
+			if (4 & e && "object" == typeof t && t && t.__esModule) return t;
+			var n = Object.create(null);
+			if (
+				(i.r(n),
+				Object.defineProperty(n, "default", { enumerable: !0, value: t }),
+				2 & e && "string" != typeof t)
+			)
+				for (var o in t)
+					i.d(
+						n,
+						o,
+						function (e) {
+							return t[e];
+						}.bind(null, o),
+					);
+			return n;
+		}),
+		(i.n = function (t) {
+			var e =
+				t && t.__esModule
+					? function () {
+							return t.default;
+						}
+					: function () {
+							return t;
+						};
+			return i.d(e, "a", e), e;
+		}),
+		(i.o = function (t, e) {
+			return Object.prototype.hasOwnProperty.call(t, e);
+		}),
+		(i.p = ""),
+		i((i.s = 5));
+})([
+	function (t, e, i) {
+		"use strict";
+		var n,
+			o =
+				(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 i in e) e.hasOwnProperty(i) && (t[i] = e[i]);
+						})(t, e);
+				}),
+				function (t, e) {
+					function i() {
+						this.constructor = t;
+					}
+					n(t, e),
+						(t.prototype =
+							null === e
+								? Object.create(e)
+								: ((i.prototype = e.prototype), new i()));
+				}),
+			r =
+				(this && this.__assign) ||
+				function () {
+					return (r =
+						Object.assign ||
+						function (t) {
+							for (var e, i = 1, n = arguments.length; i < n; i++)
+								for (var o in (e = arguments[i]))
+									Object.prototype.hasOwnProperty.call(e, o) && (t[o] = e[o]);
+							return t;
+						}).apply(this, arguments);
+				},
+			s =
+				(this && this.__read) ||
+				function (t, e) {
+					var i = "function" == typeof Symbol && t[Symbol.iterator];
+					if (!i) return t;
+					var n,
+						o,
+						r = i.call(t),
+						s = [];
+					try {
+						for (; (void 0 === e || e-- > 0) && !(n = r.next()).done; )
+							s.push(n.value);
+					} catch (t) {
+						o = { error: t };
+					} finally {
+						try {
+							n && !n.done && (i = r.return) && i.call(r);
+						} finally {
+							if (o) throw o.error;
+						}
+					}
+					return s;
+				},
+			a =
+				(this && this.__spread) ||
+				function () {
+					for (var t = [], e = 0; e < arguments.length; e++)
+						t = t.concat(s(arguments[e]));
+					return t;
+				},
+			l =
+				(this && this.__values) ||
+				function (t) {
+					var e = "function" == typeof Symbol && Symbol.iterator,
+						i = e && t[e],
+						n = 0;
+					if (i) return i.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.AssistiveMmlHandler =
+				e.AssistiveMmlMathDocumentMixin =
+				e.AssistiveMmlMathItemMixin =
+				e.LimitedMmlVisitor =
+					void 0);
+		var u = i(2),
+			c = i(3),
+			p = i(4),
+			h = (function (t) {
+				function e() {
+					return (null !== t && t.apply(this, arguments)) || this;
+				}
+				return (
+					o(e, t),
+					(e.prototype.getAttributes = function (e) {
+						return t.prototype.getAttributes
+							.call(this, e)
+							.replace(/ ?id=".*?"/, "");
+					}),
+					e
+				);
+			})(c.SerializedMmlVisitor);
+		function m(t) {
+			return (function (t) {
+				function e() {
+					return (null !== t && t.apply(this, arguments)) || this;
+				}
+				return (
+					o(e, t),
+					(e.prototype.assistiveMml = function (t, e) {
+						if (
+							(void 0 === e && (e = !1),
+							!(this.state() >= u.STATE.ASSISTIVEMML))
+						) {
+							if (!this.isEscaped && (t.options.enableAssistiveMml || e)) {
+								var i = t.adaptor,
+									n = t
+										.toMML(this.root)
+										.replace(/\n */g, "")
+										.replace(/<!--.*?-->/g, ""),
+									o = i.firstChild(i.body(i.parse(n, "text/html"))),
+									r = i.node(
+										"mjx-assistive-mml",
+										{
+											role: "presentation",
+											unselectable: "on",
+											display: this.display ? "block" : "inline",
+										},
+										[o],
+									);
+								i.setAttribute(this.typesetRoot, "role", "presentation"),
+									i.setAttribute(
+										i.firstChild(this.typesetRoot),
+										"aria-hidden",
+										"true",
+									),
+									i.setStyle(this.typesetRoot, "position", "relative"),
+									i.append(this.typesetRoot, r);
+							}
+							this.state(u.STATE.ASSISTIVEMML);
+						}
+					}),
+					e
+				);
+			})(t);
+		}
+		function f(t) {
+			var e;
+			return (
+				((e = (function (t) {
+					function e() {
+						for (var e = [], i = 0; i < arguments.length; i++)
+							e[i] = arguments[i];
+						var n = t.apply(this, a(e)) || this,
+							o = n.constructor,
+							r = o.ProcessBits;
+						return (
+							r.has("assistive-mml") || r.allocate("assistive-mml"),
+							(n.visitor = new h(n.mmlFactory)),
+							(n.options.MathItem = m(n.options.MathItem)),
+							"addStyles" in n && n.addStyles(o.assistiveStyles),
+							n
+						);
+					}
+					return (
+						o(e, t),
+						(e.prototype.toMML = function (t) {
+							return this.visitor.visitTree(t);
+						}),
+						(e.prototype.assistiveMml = function () {
+							var t, e;
+							if (!this.processed.isSet("assistive-mml")) {
+								try {
+									for (
+										var i = l(this.math), n = i.next();
+										!n.done;
+										n = i.next()
+									) {
+										n.value.assistiveMml(this);
+									}
+								} catch (e) {
+									t = { error: e };
+								} finally {
+									try {
+										n && !n.done && (e = i.return) && e.call(i);
+									} finally {
+										if (t) throw t.error;
+									}
+								}
+								this.processed.set("assistive-mml");
+							}
+							return this;
+						}),
+						(e.prototype.state = function (e, i) {
+							return (
+								void 0 === i && (i = !1),
+								t.prototype.state.call(this, e, i),
+								e < u.STATE.ASSISTIVEMML &&
+									this.processed.clear("assistive-mml"),
+								this
+							);
+						}),
+						e
+					);
+				})(t)).OPTIONS = r(r({}, t.OPTIONS), {
+					enableAssistiveMml: !0,
+					renderActions: p.expandable(
+						r(r({}, t.OPTIONS.renderActions), {
+							assistiveMml: [u.STATE.ASSISTIVEMML],
+						}),
+					),
+				})),
+				(e.assistiveStyles = {
+					"mjx-assistive-mml": {
+						position: "absolute !important",
+						top: "0px",
+						left: "0px",
+						clip: "rect(1px, 1px, 1px, 1px)",
+						padding: "1px 0px 0px 0px !important",
+						border: "0px !important",
+						display: "block !important",
+						width: "auto !important",
+						overflow: "hidden !important",
+						"-webkit-touch-callout": "none",
+						"-webkit-user-select": "none",
+						"-khtml-user-select": "none",
+						"-moz-user-select": "none",
+						"-ms-user-select": "none",
+						"user-select": "none",
+					},
+					'mjx-assistive-mml[display="block"]': { width: "100% !important" },
+				}),
+				e
+			);
+		}
+		(e.LimitedMmlVisitor = h),
+			u.newState("ASSISTIVEMML", 153),
+			(e.AssistiveMmlMathItemMixin = m),
+			(e.AssistiveMmlMathDocumentMixin = f),
+			(e.AssistiveMmlHandler = function (t) {
+				return (t.documentClass = f(t.documentClass)), t;
+			});
+	},
+	function (t, e, i) {
+		"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, i) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.protoItem = MathJax._.core.MathItem.protoItem),
+			(e.AbstractMathItem = MathJax._.core.MathItem.AbstractMathItem),
+			(e.STATE = MathJax._.core.MathItem.STATE),
+			(e.newState = MathJax._.core.MathItem.newState);
+	},
+	function (t, e, i) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.DATAMJX = MathJax._.core.MmlTree.SerializedMmlVisitor.DATAMJX),
+			(e.toEntity = MathJax._.core.MmlTree.SerializedMmlVisitor.toEntity),
+			(e.SerializedMmlVisitor =
+				MathJax._.core.MmlTree.SerializedMmlVisitor.SerializedMmlVisitor);
+	},
+	function (t, e, i) {
+		"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, i) {
+		"use strict";
+		i.r(e);
+		var n = i(1),
+			o = i(0);
+		Object(n.combineWithMathJax)({ _: { a11y: { "assistive-mml": o } } }),
+			MathJax.startup &&
+				MathJax.startup.extendHandler(function (t) {
+					return Object(o.AssistiveMmlHandler)(t);
+				});
+	},
+]);

assets/bower_components/MathJax/es5/a11y/semantic-enrich.js

@@ -0,0 +1,465 @@
+!(function (t) {
+	var e = {};
+	function n(r) {
+		if (e[r]) return e[r].exports;
+		var i = (e[r] = { i: r, l: !1, exports: {} });
+		return t[r].call(i.exports, i, i.exports, n), (i.l = !0), i.exports;
+	}
+	(n.m = t),
+		(n.c = e),
+		(n.d = function (t, e, r) {
+			n.o(t, e) || Object.defineProperty(t, e, { enumerable: !0, get: r });
+		}),
+		(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 r = Object.create(null);
+			if (
+				(n.r(r),
+				Object.defineProperty(r, "default", { enumerable: !0, value: t }),
+				2 & e && "string" != typeof t)
+			)
+				for (var i in t)
+					n.d(
+						r,
+						i,
+						function (e) {
+							return t[e];
+						}.bind(null, i),
+					);
+			return r;
+		}),
+		(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 = 9));
+})([
+	function (t, e, n) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.sreReady = void 0);
+		var r = n(8),
+			i =
+				"undefined" == typeof window
+					? "./a11y/sre-node.js"
+					: "../../../speech-rule-engine/lib/sre_browser.js",
+			a = "undefined" == typeof sre ? r.asyncLoad(i) : Promise.resolve();
+		e.sreReady = function () {
+			return new Promise(function (t, e) {
+				a.then(function () {
+					var n = new Date().getTime(),
+						r = function () {
+							sre.Engine.isReady()
+								? t()
+								: new Date().getTime() - n < 2e4
+									? setTimeout(r, 100)
+									: e("Timed out waiting for Speech-Rule-Engine");
+						};
+					r();
+				}).catch(function (t) {
+					return e(t.message || t);
+				});
+			});
+		};
+	},
+	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";
+		var r,
+			i =
+				(this && this.__extends) ||
+				((r = function (t, e) {
+					return (r =
+						Object.setPrototypeOf ||
+						({ __proto__: [] } instanceof Array &&
+							function (t, e) {
+								t.__proto__ = e;
+							}) ||
+						function (t, e) {
+							for (var n in e) e.hasOwnProperty(n) && (t[n] = e[n]);
+						})(t, e);
+				}),
+				function (t, e) {
+					function n() {
+						this.constructor = t;
+					}
+					r(t, e),
+						(t.prototype =
+							null === e
+								? Object.create(e)
+								: ((n.prototype = e.prototype), new n()));
+				}),
+			a =
+				(this && this.__assign) ||
+				function () {
+					return (a =
+						Object.assign ||
+						function (t) {
+							for (var e, n = 1, r = arguments.length; n < r; n++)
+								for (var i in (e = arguments[n]))
+									Object.prototype.hasOwnProperty.call(e, i) && (t[i] = e[i]);
+							return t;
+						}).apply(this, arguments);
+				},
+			o =
+				(this && this.__values) ||
+				function (t) {
+					var e = "function" == typeof Symbol && Symbol.iterator,
+						n = e && t[e],
+						r = 0;
+					if (n) return n.call(t);
+					if (t && "number" == typeof t.length)
+						return {
+							next: function () {
+								return (
+									t && r >= t.length && (t = void 0),
+									{ value: t && t[r++], done: !t }
+								);
+							},
+						};
+					throw new TypeError(
+						e ? "Object is not iterable." : "Symbol.iterator is not defined.",
+					);
+				},
+			s =
+				(this && this.__read) ||
+				function (t, e) {
+					var n = "function" == typeof Symbol && t[Symbol.iterator];
+					if (!n) return t;
+					var r,
+						i,
+						a = n.call(t),
+						o = [];
+					try {
+						for (; (void 0 === e || e-- > 0) && !(r = a.next()).done; )
+							o.push(r.value);
+					} catch (t) {
+						i = { error: t };
+					} finally {
+						try {
+							r && !r.done && (n = a.return) && n.call(a);
+						} finally {
+							if (i) throw i.error;
+						}
+					}
+					return o;
+				},
+			c =
+				(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.EnrichHandler =
+				e.EnrichedMathDocumentMixin =
+				e.EnrichedMathItemMixin =
+					void 0);
+		var l = n(4),
+			u = n(5),
+			h = n(6),
+			p = n(7),
+			f = n(0),
+			d = "none";
+		function y(t, e, n) {
+			return (function (t) {
+				function r() {
+					return (null !== t && t.apply(this, arguments)) || this;
+				}
+				return (
+					i(r, t),
+					(r.prototype.serializeMml = function (t) {
+						if ("outerHTML" in t) return t.outerHTML;
+						if (
+							"undefined" != typeof Element &&
+							"undefined" != typeof window &&
+							t instanceof Element
+						) {
+							var e = window.document.createElement("div");
+							return e.appendChild(t), e.innerHTML;
+						}
+						return t.toString();
+					}),
+					(r.prototype.enrich = function (t, r) {
+						if (
+							(void 0 === r && (r = !1), !(this.state() >= u.STATE.ENRICHED))
+						) {
+							if (!this.isEscaped && (t.options.enableEnrichment || r)) {
+								("undefined" != typeof sre && sre.Engine.isReady()) ||
+									l.mathjax.retryAfter(f.sreReady()),
+									t.options.enrichSpeech !== d &&
+										(SRE.setupEngine({ speech: t.options.enrichSpeech }),
+										(d = t.options.enrichSpeech));
+								var i = new t.options.MathItem("", e);
+								(i.math = this.serializeMml(SRE.toEnriched(n(this.root)))),
+									(i.display = this.display),
+									i.compile(t),
+									(this.root = i.root),
+									(this.inputData.originalMml = i.math);
+							}
+							this.state(u.STATE.ENRICHED);
+						}
+					}),
+					(r.prototype.attachSpeech = function (t) {
+						var e, n;
+						if (!(this.state() >= u.STATE.ATTACHSPEECH)) {
+							var r =
+								this.root.attributes.get("aria-label") ||
+								this.getSpeech(this.root);
+							if (r) {
+								var i = t.adaptor,
+									a = this.typesetRoot;
+								i.setAttribute(a, "aria-label", r);
+								try {
+									for (
+										var s = o(i.childNodes(a)), c = s.next();
+										!c.done;
+										c = s.next()
+									) {
+										var l = c.value;
+										i.setAttribute(l, "aria-hidden", "true");
+									}
+								} catch (t) {
+									e = { error: t };
+								} finally {
+									try {
+										c && !c.done && (n = s.return) && n.call(s);
+									} finally {
+										if (e) throw e.error;
+									}
+								}
+							}
+							this.state(u.STATE.ATTACHSPEECH);
+						}
+					}),
+					(r.prototype.getSpeech = function (t) {
+						var e,
+							n,
+							r = t.attributes;
+						if (!r) return "";
+						var i = r.getExplicit("data-semantic-speech");
+						if (!r.getExplicit("data-semantic-parent") && i) return i;
+						try {
+							for (
+								var a = o(t.childNodes), s = a.next();
+								!s.done;
+								s = a.next()
+							) {
+								var c = s.value,
+									l = this.getSpeech(c);
+								if (null != l) return l;
+							}
+						} catch (t) {
+							e = { error: t };
+						} finally {
+							try {
+								s && !s.done && (n = a.return) && n.call(a);
+							} finally {
+								if (e) throw e.error;
+							}
+						}
+						return "";
+					}),
+					r
+				);
+			})(t);
+		}
+		function M(t, e) {
+			var n;
+			return (
+				((n = (function (t) {
+					function n() {
+						for (var n = [], r = 0; r < arguments.length; r++)
+							n[r] = arguments[r];
+						var i = t.apply(this, c(n)) || this;
+						e.setMmlFactory(i.mmlFactory);
+						var a = i.constructor.ProcessBits;
+						a.has("enriched") ||
+							(a.allocate("enriched"), a.allocate("attach-speech"));
+						var o = new h.SerializedMmlVisitor(i.mmlFactory),
+							s = function (t) {
+								return o.visitTree(t);
+							};
+						return (i.options.MathItem = y(i.options.MathItem, e, s)), i;
+					}
+					return (
+						i(n, t),
+						(n.prototype.attachSpeech = function () {
+							var t, e;
+							if (!this.processed.isSet("attach-speech")) {
+								try {
+									for (
+										var n = o(this.math), r = n.next();
+										!r.done;
+										r = n.next()
+									) {
+										r.value.attachSpeech(this);
+									}
+								} catch (e) {
+									t = { error: e };
+								} finally {
+									try {
+										r && !r.done && (e = n.return) && e.call(n);
+									} finally {
+										if (t) throw t.error;
+									}
+								}
+								this.processed.set("attach-speech");
+							}
+							return this;
+						}),
+						(n.prototype.enrich = function () {
+							var t, e;
+							if (!this.processed.isSet("enriched")) {
+								if (this.options.enableEnrichment)
+									try {
+										for (
+											var n = o(this.math), r = n.next();
+											!r.done;
+											r = n.next()
+										) {
+											r.value.enrich(this);
+										}
+									} catch (e) {
+										t = { error: e };
+									} finally {
+										try {
+											r && !r.done && (e = n.return) && e.call(n);
+										} finally {
+											if (t) throw t.error;
+										}
+									}
+								this.processed.set("enriched");
+							}
+							return this;
+						}),
+						(n.prototype.state = function (e, n) {
+							return (
+								void 0 === n && (n = !1),
+								t.prototype.state.call(this, e, n),
+								e < u.STATE.ENRICHED && this.processed.clear("enriched"),
+								this
+							);
+						}),
+						n
+					);
+				})(t)).OPTIONS = a(a({}, t.OPTIONS), {
+					enableEnrichment: !0,
+					enrichSpeech: "none",
+					renderActions: p.expandable(
+						a(a({}, t.OPTIONS.renderActions), {
+							enrich: [u.STATE.ENRICHED],
+							attachSpeech: [u.STATE.ATTACHSPEECH],
+						}),
+					),
+				})),
+				n
+			);
+		}
+		u.newState("ENRICHED", 30),
+			u.newState("ATTACHSPEECH", 155),
+			(e.EnrichedMathItemMixin = y),
+			(e.EnrichedMathDocumentMixin = M),
+			(e.EnrichHandler = function (t, e) {
+				return (
+					e.setAdaptor(t.adaptor), (t.documentClass = M(t.documentClass, e)), t
+				);
+			});
+	},
+	function (t, e, n) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.MathML = MathJax._.input.mathml_ts.MathML);
+	},
+	function (t, e, n) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.mathjax = MathJax._.mathjax.mathjax);
+	},
+	function (t, e, n) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.protoItem = MathJax._.core.MathItem.protoItem),
+			(e.AbstractMathItem = MathJax._.core.MathItem.AbstractMathItem),
+			(e.STATE = MathJax._.core.MathItem.STATE),
+			(e.newState = MathJax._.core.MathItem.newState);
+	},
+	function (t, e, n) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.DATAMJX = MathJax._.core.MmlTree.SerializedMmlVisitor.DATAMJX),
+			(e.toEntity = MathJax._.core.MmlTree.SerializedMmlVisitor.toEntity),
+			(e.SerializedMmlVisitor =
+				MathJax._.core.MmlTree.SerializedMmlVisitor.SerializedMmlVisitor);
+	},
+	function (t, e, n) {
+		"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, n) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.asyncLoad = MathJax._.util.AsyncLoad.asyncLoad);
+	},
+	function (t, e, n) {
+		"use strict";
+		n.r(e);
+		var r = n(1),
+			i = n(2),
+			a = n(0);
+		Object(r.combineWithMathJax)({
+			_: { a11y: { "semantic-enrich": i, sre: a } },
+		});
+		var o = n(3);
+		MathJax.loader &&
+			Object(r.combineDefaults)(MathJax.config.loader, "a11y/semantic-enrich", {
+				checkReady: function () {
+					return Object(a.sreReady)();
+				},
+			}),
+			MathJax.startup &&
+				MathJax.startup.extendHandler(function (t) {
+					return Object(i.EnrichHandler)(t, new o.MathML());
+				});
+	},
+]);

assets/bower_components/MathJax/es5/input/mml.js

@@ -0,0 +1,774 @@
+!(function (t) {
+	var e = {};
+	function r(o) {
+		if (e[o]) return e[o].exports;
+		var a = (e[o] = { i: o, l: !1, exports: {} });
+		return t[o].call(a.exports, a, a.exports, r), (a.l = !0), a.exports;
+	}
+	(r.m = t),
+		(r.c = e),
+		(r.d = function (t, e, o) {
+			r.o(t, e) || Object.defineProperty(t, e, { enumerable: !0, get: o });
+		}),
+		(r.r = function (t) {
+			"undefined" != typeof Symbol &&
+				Symbol.toStringTag &&
+				Object.defineProperty(t, Symbol.toStringTag, { value: "Module" }),
+				Object.defineProperty(t, "__esModule", { value: !0 });
+		}),
+		(r.t = function (t, e) {
+			if ((1 & e && (t = r(t)), 8 & e)) return t;
+			if (4 & e && "object" == typeof t && t && t.__esModule) return t;
+			var o = Object.create(null);
+			if (
+				(r.r(o),
+				Object.defineProperty(o, "default", { enumerable: !0, value: t }),
+				2 & e && "string" != typeof t)
+			)
+				for (var a in t)
+					r.d(
+						o,
+						a,
+						function (e) {
+							return t[e];
+						}.bind(null, a),
+					);
+			return o;
+		}),
+		(r.n = function (t) {
+			var e =
+				t && t.__esModule
+					? function () {
+							return t.default;
+						}
+					: function () {
+							return t;
+						};
+			return r.d(e, "a", e), e;
+		}),
+		(r.o = function (t, e) {
+			return Object.prototype.hasOwnProperty.call(t, e);
+		}),
+		(r.p = ""),
+		r((r.s = 10));
+})([
+	function (t, e, r) {
+		"use strict";
+		var o,
+			a =
+				(this && this.__extends) ||
+				((o = function (t, e) {
+					return (o =
+						Object.setPrototypeOf ||
+						({ __proto__: [] } instanceof Array &&
+							function (t, e) {
+								t.__proto__ = e;
+							}) ||
+						function (t, e) {
+							for (var r in e) e.hasOwnProperty(r) && (t[r] = e[r]);
+						})(t, e);
+				}),
+				function (t, e) {
+					function r() {
+						this.constructor = t;
+					}
+					o(t, e),
+						(t.prototype =
+							null === e
+								? Object.create(e)
+								: ((r.prototype = e.prototype), new r()));
+				}),
+			i =
+				(this && this.__read) ||
+				function (t, e) {
+					var r = "function" == typeof Symbol && t[Symbol.iterator];
+					if (!r) return t;
+					var o,
+						a,
+						i = r.call(t),
+						n = [];
+					try {
+						for (; (void 0 === e || e-- > 0) && !(o = i.next()).done; )
+							n.push(o.value);
+					} catch (t) {
+						a = { error: t };
+					} finally {
+						try {
+							o && !o.done && (r = i.return) && r.call(i);
+						} finally {
+							if (a) throw a.error;
+						}
+					}
+					return n;
+				};
+		Object.defineProperty(e, "__esModule", { value: !0 }), (e.MathML = void 0);
+		var n = r(5),
+			s = r(3),
+			l = r(6),
+			c = r(1),
+			u = r(2),
+			h = (function (t) {
+				function e(e) {
+					void 0 === e && (e = {});
+					var r = this,
+						o = i(
+							s.separateOptions(
+								e,
+								c.FindMathML.OPTIONS,
+								u.MathMLCompile.OPTIONS,
+							),
+							3,
+						),
+						a = o[0],
+						n = o[1],
+						h = o[2];
+					return (
+						((r = t.call(this, a) || this).findMathML =
+							r.options.FindMathML || new c.FindMathML(n)),
+						(r.mathml = r.options.MathMLCompile || new u.MathMLCompile(h)),
+						(r.mmlFilters = new l.FunctionList()),
+						r
+					);
+				}
+				return (
+					a(e, t),
+					(e.prototype.setAdaptor = function (e) {
+						t.prototype.setAdaptor.call(this, e),
+							(this.findMathML.adaptor = e),
+							(this.mathml.adaptor = e);
+					}),
+					(e.prototype.setMmlFactory = function (e) {
+						t.prototype.setMmlFactory.call(this, e),
+							this.mathml.setMmlFactory(e);
+					}),
+					Object.defineProperty(e.prototype, "processStrings", {
+						get: function () {
+							return !1;
+						},
+						enumerable: !1,
+						configurable: !0,
+					}),
+					(e.prototype.compile = function (t, e) {
+						var r = t.start.node;
+						if (
+							!r ||
+							!t.end.node ||
+							this.options.forceReparse ||
+							"#text" === this.adaptor.kind(r)
+						) {
+							var o = this.executeFilters(
+									this.preFilters,
+									t,
+									e,
+									t.math || "<math></math>",
+								),
+								a = this.checkForErrors(
+									this.adaptor.parse(o, "text/" + this.options.parseAs),
+								),
+								i = this.adaptor.body(a);
+							1 !== this.adaptor.childNodes(i).length &&
+								this.error("MathML must consist of a single element"),
+								(r = this.adaptor.remove(this.adaptor.firstChild(i))),
+								"math" !== this.adaptor.kind(r).replace(/^[a-z]+:/, "") &&
+									this.error(
+										"MathML must be formed by a <math> element, not <" +
+											this.adaptor.kind(r) +
+											">",
+									);
+						}
+						return (
+							(r = this.executeFilters(this.mmlFilters, t, e, r)),
+							this.executeFilters(
+								this.postFilters,
+								t,
+								e,
+								this.mathml.compile(r),
+							)
+						);
+					}),
+					(e.prototype.checkForErrors = function (t) {
+						var e = this.adaptor.tags(this.adaptor.body(t), "parsererror")[0];
+						return (
+							e &&
+								("" === this.adaptor.textContent(e) &&
+									this.error("Error processing MathML"),
+								this.options.parseError.call(this, e)),
+							t
+						);
+					}),
+					(e.prototype.error = function (t) {
+						throw new Error(t);
+					}),
+					(e.prototype.findMath = function (t) {
+						return this.findMathML.findMath(t);
+					}),
+					(e.NAME = "MathML"),
+					(e.OPTIONS = s.defaultOptions(
+						{
+							parseAs: "html",
+							forceReparse: !1,
+							FindMathML: null,
+							MathMLCompile: null,
+							parseError: function (t) {
+								this.error(this.adaptor.textContent(t).replace(/\n.*/g, ""));
+							},
+						},
+						n.AbstractInputJax.OPTIONS,
+					)),
+					e
+				);
+			})(n.AbstractInputJax);
+		e.MathML = h;
+	},
+	function (t, e, r) {
+		"use strict";
+		var o,
+			a =
+				(this && this.__extends) ||
+				((o = function (t, e) {
+					return (o =
+						Object.setPrototypeOf ||
+						({ __proto__: [] } instanceof Array &&
+							function (t, e) {
+								t.__proto__ = e;
+							}) ||
+						function (t, e) {
+							for (var r in e) e.hasOwnProperty(r) && (t[r] = e[r]);
+						})(t, e);
+				}),
+				function (t, e) {
+					function r() {
+						this.constructor = t;
+					}
+					o(t, e),
+						(t.prototype =
+							null === e
+								? Object.create(e)
+								: ((r.prototype = e.prototype), new r()));
+				}),
+			i =
+				(this && this.__values) ||
+				function (t) {
+					var e = "function" == typeof Symbol && Symbol.iterator,
+						r = e && t[e],
+						o = 0;
+					if (r) return r.call(t);
+					if (t && "number" == typeof t.length)
+						return {
+							next: function () {
+								return (
+									t && o >= t.length && (t = void 0),
+									{ value: t && t[o++], done: !t }
+								);
+							},
+						};
+					throw new TypeError(
+						e ? "Object is not iterable." : "Symbol.iterator is not defined.",
+					);
+				};
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.FindMathML = void 0);
+		var n = r(7),
+			s = "http://www.w3.org/1998/Math/MathML",
+			l = (function (t) {
+				function e() {
+					return (null !== t && t.apply(this, arguments)) || this;
+				}
+				return (
+					a(e, t),
+					(e.prototype.findMath = function (t) {
+						var e = new Set();
+						this.findMathNodes(t, e), this.findMathPrefixed(t, e);
+						var r = this.adaptor.root(this.adaptor.document);
+						return (
+							"html" === this.adaptor.kind(r) &&
+								0 === e.size &&
+								this.findMathNS(t, e),
+							this.processMath(e)
+						);
+					}),
+					(e.prototype.findMathNodes = function (t, e) {
+						var r, o;
+						try {
+							for (
+								var a = i(this.adaptor.tags(t, "math")), n = a.next();
+								!n.done;
+								n = a.next()
+							) {
+								var s = n.value;
+								e.add(s);
+							}
+						} catch (t) {
+							r = { error: t };
+						} finally {
+							try {
+								n && !n.done && (o = a.return) && o.call(a);
+							} finally {
+								if (r) throw r.error;
+							}
+						}
+					}),
+					(e.prototype.findMathPrefixed = function (t, e) {
+						var r,
+							o,
+							a,
+							n,
+							l = this.adaptor.root(this.adaptor.document);
+						try {
+							for (
+								var c = i(this.adaptor.allAttributes(l)), u = c.next();
+								!u.done;
+								u = c.next()
+							) {
+								var h = u.value;
+								if ("xmlns:" === h.name.substr(0, 6) && h.value === s) {
+									var p = h.name.substr(6);
+									try {
+										for (
+											var d =
+													((a = void 0), i(this.adaptor.tags(t, p + ":math"))),
+												f = d.next();
+											!f.done;
+											f = d.next()
+										) {
+											var M = f.value;
+											e.add(M);
+										}
+									} catch (t) {
+										a = { error: t };
+									} finally {
+										try {
+											f && !f.done && (n = d.return) && n.call(d);
+										} finally {
+											if (a) throw a.error;
+										}
+									}
+								}
+							}
+						} catch (t) {
+							r = { error: t };
+						} finally {
+							try {
+								u && !u.done && (o = c.return) && o.call(c);
+							} finally {
+								if (r) throw r.error;
+							}
+						}
+					}),
+					(e.prototype.findMathNS = function (t, e) {
+						var r, o;
+						try {
+							for (
+								var a = i(this.adaptor.tags(t, "math", s)), n = a.next();
+								!n.done;
+								n = a.next()
+							) {
+								var l = n.value;
+								e.add(l);
+							}
+						} catch (t) {
+							r = { error: t };
+						} finally {
+							try {
+								n && !n.done && (o = a.return) && o.call(a);
+							} finally {
+								if (r) throw r.error;
+							}
+						}
+					}),
+					(e.prototype.processMath = function (t) {
+						var e,
+							r,
+							o = [];
+						try {
+							for (
+								var a = i(Array.from(t)), n = a.next();
+								!n.done;
+								n = a.next()
+							) {
+								var s = n.value,
+									l =
+										"block" === this.adaptor.getAttribute(s, "display") ||
+										"display" === this.adaptor.getAttribute(s, "mode"),
+									c = { node: s, n: 0, delim: "" },
+									u = { node: s, n: 0, delim: "" };
+								o.push({
+									math: this.adaptor.outerHTML(s),
+									start: c,
+									end: u,
+									display: l,
+								});
+							}
+						} catch (t) {
+							e = { error: t };
+						} finally {
+							try {
+								n && !n.done && (r = a.return) && r.call(a);
+							} finally {
+								if (e) throw e.error;
+							}
+						}
+						return o;
+					}),
+					(e.OPTIONS = {}),
+					e
+				);
+			})(n.AbstractFindMath);
+		e.FindMathML = l;
+	},
+	function (t, e, r) {
+		"use strict";
+		var o =
+				(this && this.__assign) ||
+				function () {
+					return (o =
+						Object.assign ||
+						function (t) {
+							for (var e, r = 1, o = arguments.length; r < o; r++)
+								for (var a in (e = arguments[r]))
+									Object.prototype.hasOwnProperty.call(e, a) && (t[a] = e[a]);
+							return t;
+						}).apply(this, arguments);
+				},
+			a =
+				(this && this.__values) ||
+				function (t) {
+					var e = "function" == typeof Symbol && Symbol.iterator,
+						r = e && t[e],
+						o = 0;
+					if (r) return r.call(t);
+					if (t && "number" == typeof t.length)
+						return {
+							next: function () {
+								return (
+									t && o >= t.length && (t = void 0),
+									{ value: t && t[o++], done: !t }
+								);
+							},
+						};
+					throw new TypeError(
+						e ? "Object is not iterable." : "Symbol.iterator is not defined.",
+					);
+				};
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.MathMLCompile = void 0);
+		var i = r(8),
+			n = r(3),
+			s = r(9),
+			l = (function () {
+				function t(t) {
+					void 0 === t && (t = {});
+					var e = this.constructor;
+					this.options = n.userOptions(n.defaultOptions({}, e.OPTIONS), t);
+				}
+				return (
+					(t.prototype.setMmlFactory = function (t) {
+						this.factory = t;
+					}),
+					(t.prototype.compile = function (t) {
+						var e = this.makeNode(t);
+						return (
+							e.verifyTree(this.options.verify),
+							e.setInheritedAttributes({}, !1, 0, !1),
+							e.walkTree(this.markMrows),
+							e
+						);
+					}),
+					(t.prototype.makeNode = function (t) {
+						var e,
+							r,
+							o = this.adaptor,
+							n = !1,
+							s = o.kind(t).replace(/^.*:/, ""),
+							l = o.getAttribute(t, "data-mjx-texclass") || "";
+						l && (l = this.filterAttribute("data-mjx-texclass", l) || "");
+						var c = l && "mrow" === s ? "TeXAtom" : s;
+						try {
+							for (
+								var u = a(this.filterClassList(o.allClasses(t))), h = u.next();
+								!h.done;
+								h = u.next()
+							) {
+								var p = h.value;
+								p.match(/^MJX-TeXAtom-/)
+									? ((l = p.substr(12)), (c = "TeXAtom"))
+									: "MJX-fixedlimits" === p && (n = !0);
+							}
+						} catch (t) {
+							e = { error: t };
+						} finally {
+							try {
+								h && !h.done && (r = u.return) && r.call(u);
+							} finally {
+								if (e) throw e.error;
+							}
+						}
+						this.factory.getNodeClass(c) ||
+							this.error('Unknown node type "' + c + '"');
+						var d = this.factory.create(c);
+						return (
+							"TeXAtom" === c
+								? this.texAtom(d, l, n)
+								: l &&
+									((d.texClass = i.TEXCLASS[l]),
+									d.setProperty("texClass", d.texClass)),
+							this.addAttributes(d, t),
+							this.checkClass(d, t),
+							this.addChildren(d, t),
+							d
+						);
+					}),
+					(t.prototype.addAttributes = function (t, e) {
+						var r,
+							o,
+							i = !1;
+						try {
+							for (
+								var n = a(this.adaptor.allAttributes(e)), s = n.next();
+								!s.done;
+								s = n.next()
+							) {
+								var l = s.value,
+									c = l.name,
+									u = this.filterAttribute(c, l.value);
+								if (null === u) return;
+								if ("data-mjx-" === c.substr(0, 9))
+									"data-mjx-alternate" === c
+										? t.setProperty("variantForm", !0)
+										: "data-mjx-variant" === c &&
+											(t.attributes.set("mathvariant", u), (i = !0));
+								else if ("class" !== c) {
+									var h = u.toLowerCase();
+									"true" === h || "false" === h
+										? t.attributes.set(c, "true" === h)
+										: (i && "mathvariant" === c) || t.attributes.set(c, u);
+								}
+							}
+						} catch (t) {
+							r = { error: t };
+						} finally {
+							try {
+								s && !s.done && (o = n.return) && o.call(n);
+							} finally {
+								if (r) throw r.error;
+							}
+						}
+					}),
+					(t.prototype.filterAttribute = function (t, e) {
+						return e;
+					}),
+					(t.prototype.filterClassList = function (t) {
+						return t;
+					}),
+					(t.prototype.addChildren = function (t, e) {
+						var r, o;
+						if (0 !== t.arity) {
+							var i = this.adaptor;
+							try {
+								for (
+									var n = a(i.childNodes(e)), s = n.next();
+									!s.done;
+									s = n.next()
+								) {
+									var l = s.value,
+										c = i.kind(l);
+									if ("#comment" !== c)
+										if ("#text" === c) this.addText(t, l);
+										else if (t.isKind("annotation-xml"))
+											t.appendChild(this.factory.create("XML").setXML(l, i));
+										else {
+											var u = t.appendChild(this.makeNode(l));
+											0 === u.arity &&
+												i.childNodes(l).length &&
+												(this.options.fixMisplacedChildren
+													? this.addChildren(t, l)
+													: u.mError(
+															"There should not be children for " +
+																u.kind +
+																" nodes",
+															this.options.verify,
+															!0,
+														));
+										}
+								}
+							} catch (t) {
+								r = { error: t };
+							} finally {
+								try {
+									s && !s.done && (o = n.return) && o.call(n);
+								} finally {
+									if (r) throw r.error;
+								}
+							}
+						}
+					}),
+					(t.prototype.addText = function (t, e) {
+						var r = this.adaptor.value(e);
+						(t.isToken || t.getProperty("isChars")) && t.arity
+							? (t.isToken && ((r = s.translate(r)), (r = this.trimSpace(r))),
+								t.appendChild(this.factory.create("text").setText(r)))
+							: r.match(/\S/) && this.error('Unexpected text node "' + r + '"');
+					}),
+					(t.prototype.checkClass = function (t, e) {
+						var r,
+							o,
+							i = [];
+						try {
+							for (
+								var n = a(this.filterClassList(this.adaptor.allClasses(e))),
+									s = n.next();
+								!s.done;
+								s = n.next()
+							) {
+								var l = s.value;
+								"MJX-" === l.substr(0, 4)
+									? "MJX-variant" === l
+										? t.setProperty("variantForm", !0)
+										: "MJX-TeXAtom" !== l.substr(0, 11) &&
+											t.attributes.set(
+												"mathvariant",
+												this.fixCalligraphic(l.substr(3)),
+											)
+									: i.push(l);
+							}
+						} catch (t) {
+							r = { error: t };
+						} finally {
+							try {
+								s && !s.done && (o = n.return) && o.call(n);
+							} finally {
+								if (r) throw r.error;
+							}
+						}
+						i.length && t.attributes.set("class", i.join(" "));
+					}),
+					(t.prototype.fixCalligraphic = function (t) {
+						return t.replace(/caligraphic/, "calligraphic");
+					}),
+					(t.prototype.texAtom = function (t, e, r) {
+						(t.texClass = i.TEXCLASS[e]),
+							t.setProperty("texClass", t.texClass),
+							"OP" !== e ||
+								r ||
+								(t.setProperty("movesupsub", !0),
+								t.attributes.setInherited("movablelimits", !0));
+					}),
+					(t.prototype.markMrows = function (t) {
+						if (t.isKind("mrow") && !t.isInferred && t.childNodes.length >= 2) {
+							var e = t.childNodes[0],
+								r = t.childNodes[t.childNodes.length - 1];
+							e.isKind("mo") &&
+								e.attributes.get("fence") &&
+								r.isKind("mo") &&
+								r.attributes.get("fence") &&
+								(e.childNodes.length && t.setProperty("open", e.getText()),
+								r.childNodes.length && t.setProperty("close", r.getText()));
+						}
+					}),
+					(t.prototype.trimSpace = function (t) {
+						return t
+							.replace(/[\t\n\r]/g, " ")
+							.replace(/^ +/, "")
+							.replace(/ +$/, "")
+							.replace(/  +/g, " ");
+					}),
+					(t.prototype.error = function (t) {
+						throw new Error(t);
+					}),
+					(t.OPTIONS = {
+						MmlFactory: null,
+						fixMisplacedChildren: !0,
+						verify: o({}, i.AbstractMmlNode.verifyDefaults),
+						translateEntities: !0,
+					}),
+					t
+				);
+			})();
+		e.MathMLCompile = l;
+	},
+	function (t, e, r) {
+		"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, r) {
+		"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, r) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.AbstractInputJax = MathJax._.core.InputJax.AbstractInputJax);
+	},
+	function (t, e, r) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.FunctionList = MathJax._.util.FunctionList.FunctionList);
+	},
+	function (t, e, r) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.AbstractFindMath = MathJax._.core.FindMath.AbstractFindMath);
+	},
+	function (t, e, r) {
+		"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, r) {
+		"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, r) {
+		"use strict";
+		r.r(e);
+		var o = r(4),
+			a = r(0),
+			i = r(1),
+			n = r(2);
+		Object(o.combineWithMathJax)({
+			_: {
+				input: { mathml_ts: a, mathml: { FindMathML: i, MathMLCompile: n } },
+			},
+		}),
+			MathJax.startup &&
+				(MathJax.startup.registerConstructor("mml", a.MathML),
+				MathJax.startup.useInput("mml"));
+	},
+]);

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 } } } },
+		});
+	},
+]);

assets/bower_components/MathJax/es5/latest.js

@@ -0,0 +1,337 @@
+!(function (t) {
+	var e = {};
+	function r(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, r), (n.l = !0), n.exports;
+	}
+	(r.m = t),
+		(r.c = e),
+		(r.d = function (t, e, a) {
+			r.o(t, e) || Object.defineProperty(t, e, { enumerable: !0, get: a });
+		}),
+		(r.r = function (t) {
+			"undefined" != typeof Symbol &&
+				Symbol.toStringTag &&
+				Object.defineProperty(t, Symbol.toStringTag, { value: "Module" }),
+				Object.defineProperty(t, "__esModule", { value: !0 });
+		}),
+		(r.t = function (t, e) {
+			if ((1 & e && (t = r(t)), 8 & e)) return t;
+			if (4 & e && "object" == typeof t && t && t.__esModule) return t;
+			var a = Object.create(null);
+			if (
+				(r.r(a),
+				Object.defineProperty(a, "default", { enumerable: !0, value: t }),
+				2 & e && "string" != typeof t)
+			)
+				for (var n in t)
+					r.d(
+						a,
+						n,
+						function (e) {
+							return t[e];
+						}.bind(null, n),
+					);
+			return a;
+		}),
+		(r.n = function (t) {
+			var e =
+				t && t.__esModule
+					? function () {
+							return t.default;
+						}
+					: function () {
+							return t;
+						};
+			return r.d(e, "a", e), e;
+		}),
+		(r.o = function (t, e) {
+			return Object.prototype.hasOwnProperty.call(t, e);
+		}),
+		(r.p = ""),
+		r((r.s = 1));
+})([
+	function (t, e, r) {
+		"use strict";
+		var a =
+				(this && this.__values) ||
+				function (t) {
+					var e = "function" == typeof Symbol && Symbol.iterator,
+						r = e && t[e],
+						a = 0;
+					if (r) return r.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.",
+					);
+				},
+			n =
+				(this && this.__read) ||
+				function (t, e) {
+					var r = "function" == typeof Symbol && t[Symbol.iterator];
+					if (!r) return t;
+					var a,
+						n,
+						o = r.call(t),
+						i = [];
+					try {
+						for (; (void 0 === e || e-- > 0) && !(a = o.next()).done; )
+							i.push(a.value);
+					} catch (t) {
+						n = { error: t };
+					} finally {
+						try {
+							a && !a.done && (r = o.return) && r.call(o);
+						} finally {
+							if (n) throw n.error;
+						}
+					}
+					return i;
+				};
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.loadLatest = void 0);
+		var o = new Map([
+				[
+					"cdnjs.cloudflare.com",
+					{
+						api: "https://api.cdnjs.com/libraries/mathjax?fields=version",
+						key: "version",
+						base: "https://cdnjs.cloudflare.com/ajax/libs/mathjax/",
+					},
+				],
+				[
+					"rawcdn.githack.com",
+					{
+						api: "https://api.github.com/repos/mathjax/mathjax/releases/latest",
+						key: "tag_name",
+						base: "https://rawcdn.githack.com/mathjax/MathJax/",
+					},
+				],
+				[
+					"gitcdn.xyz",
+					{
+						api: "https://api.github.com/repos/mathjax/mathjax/releases/latest",
+						key: "tag_name",
+						base: "https://gitcdn.xyz/mathjax/MathJax/",
+					},
+				],
+				[
+					"cdn.statically.io",
+					{
+						api: "https://api.github.com/repos/mathjax/mathjax/releases/latest",
+						key: "tag_name",
+						base: "https://cdn.statically.io/gh/mathjax/MathJax/",
+					},
+				],
+				[
+					"unpkg.com",
+					{
+						api: "https://api.github.com/repos/mathjax/mathjax/releases/latest",
+						key: "tag_name",
+						base: "https://unpkg.com/mathjax@",
+					},
+				],
+				[
+					"cdn.jsdelivr.net",
+					{
+						api: "https://api.github.com/repos/mathjax/mathjax/releases/latest",
+						key: "tag_name",
+						base: "https://cdn.jsdelivr.net/npm/mathjax@",
+					},
+				],
+			]),
+			i = {
+				api: "https://api.github.com/repos/mathjax/mathjax/releases",
+				key: "tag_name",
+			},
+			c = null;
+		function s(t) {
+			console && console.error && console.error("MathJax(latest.js): " + t);
+		}
+		function l(t, e) {
+			void 0 === e && (e = null), t.parentNode.removeChild(t);
+			var r = t.src,
+				a = r.replace(/.*?\/latest\.js(\?|$)/, "");
+			"" === a && ((a = "startup.js"), (r = r.replace(/\?$/, "") + "?" + a));
+			var n = (r.match(/(\d+\.\d+\.\d+)(\/es\d+)?\/latest.js\?/) || [
+					"",
+					"",
+				])[1],
+				o = (r.match(/(\/es\d+)\/latest.js\?/) || ["", ""])[1] || "";
+			return { tag: t, src: r, id: t.id, version: n, dir: o, file: a, cdn: e };
+		}
+		function u(t) {
+			var e, r;
+			try {
+				for (var n = a(o.keys()), i = n.next(); !i.done; i = n.next()) {
+					var c = i.value,
+						s = o.get(c),
+						u = s.base,
+						d = t.src;
+					if (d && d.substr(0, u.length) === u && d.match(/\/latest\.js(\?|$)/))
+						return l(t, s);
+				}
+			} catch (t) {
+				e = { error: t };
+			} finally {
+				try {
+					i && !i.done && (r = n.return) && r.call(n);
+				} finally {
+					if (e) throw e.error;
+				}
+			}
+			return null;
+		}
+		function d(t, e) {
+			var r = document.createElement("script");
+			(r.type = "text/javascript"),
+				(r.async = !0),
+				(r.src = t),
+				e && (r.id = e);
+			var a =
+				document.head ||
+				document.getElementsByTagName("head")[0] ||
+				document.body;
+			a ? a.appendChild(r) : s("Can't find the document <head> element");
+		}
+		function f() {
+			c
+				? d(c.src.replace(/\/latest\.js\?/, "/"), c.id)
+				: s("Can't determine the URL for loading MathJax");
+		}
+		function p(t) {
+			c.version && c.version !== t && (c.file = "latest.js?" + c.file),
+				d(c.cdn.base + t + c.dir + "/" + c.file, c.id);
+		}
+		function h(t) {
+			return (
+				3 === parseInt(t.split(/\./)[0]) &&
+				!t.match(/-(beta|rc)/) &&
+				((function (t) {
+					try {
+						var e = t + " " + Date.now();
+						localStorage.setItem("mjx-latest-version", e);
+					} catch (t) {}
+				})(t),
+				p(t),
+				!0)
+			);
+		}
+		function m(t, e, r) {
+			var a = (function () {
+				if (window.XMLHttpRequest) return new XMLHttpRequest();
+				if (window.ActiveXObject) {
+					try {
+						return new window.ActiveXObject("Msxml2.XMLHTTP");
+					} catch (t) {}
+					try {
+						return new window.ActiveXObject("Microsoft.XMLHTTP");
+					} catch (t) {}
+				}
+				return null;
+			})();
+			a
+				? ((a.onreadystatechange = function () {
+						4 === a.readyState &&
+							(200 === a.status
+								? !e(JSON.parse(a.responseText)) && r()
+								: (s("Problem acquiring MathJax version: status = " + a.status),
+									r()));
+					}),
+					a.open("GET", t.api, !0),
+					a.send(null))
+				: (s("Can't create XMLHttpRequest object"), r());
+		}
+		function y() {
+			m(
+				c.cdn,
+				function (t) {
+					return (
+						t instanceof Array && (t = t[0]),
+						h(t[c.cdn.key]) ||
+							m(
+								i,
+								function (t) {
+									var e, r;
+									if (!(t instanceof Array)) return !1;
+									try {
+										for (var n = a(t), o = n.next(); !o.done; o = n.next())
+											if (h(o.value[i.key])) return !0;
+									} catch (t) {
+										e = { error: t };
+									} finally {
+										try {
+											o && !o.done && (r = n.return) && r.call(n);
+										} finally {
+											if (e) throw e.error;
+										}
+									}
+									return !1;
+								},
+								f,
+							),
+						!0
+					);
+				},
+				f,
+			);
+		}
+		e.loadLatest = function () {
+			if (
+				(c = (function () {
+					var t, e;
+					if (document.currentScript) return l(document.currentScript);
+					var r = document.getElementById("MathJax-script");
+					if (r && "script" === r.nodeName.toLowerCase()) return u(r);
+					var n = document.getElementsByTagName("script");
+					try {
+						for (
+							var o = a(Array.from(n)), i = o.next();
+							!i.done;
+							i = o.next()
+						) {
+							var c = u(i.value);
+							if (c) return c;
+						}
+					} catch (e) {
+						t = { error: e };
+					} finally {
+						try {
+							i && !i.done && (e = o.return) && e.call(o);
+						} finally {
+							if (t) throw t.error;
+						}
+					}
+					return null;
+				})()) &&
+				c.cdn
+			) {
+				var t = (function () {
+					try {
+						var t = n(localStorage.getItem("mjx-latest-version").split(/ /), 2),
+							e = t[0],
+							r = t[1];
+						if (r && Date.now() - parseInt(r) < 6048e5) return e;
+					} catch (t) {}
+					return null;
+				})();
+				t ? p(t) : y();
+			} else f();
+		};
+	},
+	function (t, e, r) {
+		"use strict";
+		r.r(e);
+		var a = r(0);
+		Object(a.loadLatest)();
+	},
+]);

assets/bower_components/MathJax/es5/loader.js

@@ -0,0 +1,793 @@
+!(function (e) {
+	var t = {};
+	function n(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, n), (o.l = !0), o.exports;
+	}
+	(n.m = e),
+		(n.c = t),
+		(n.d = function (e, t, r) {
+			n.o(e, t) || Object.defineProperty(e, t, { enumerable: !0, get: r });
+		}),
+		(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 r = Object.create(null);
+			if (
+				(n.r(r),
+				Object.defineProperty(r, "default", { enumerable: !0, value: e }),
+				2 & t && "string" != typeof e)
+			)
+				for (var o in e)
+					n.d(
+						r,
+						o,
+						function (t) {
+							return e[t];
+						}.bind(null, o),
+					);
+			return r;
+		}),
+		(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 = 4));
+})([
+	function (e, t, n) {
+		"use strict";
+		(function (e) {
+			var r =
+				(this && this.__values) ||
+				function (e) {
+					var t = "function" == typeof Symbol && Symbol.iterator,
+						n = t && e[t],
+						r = 0;
+					if (n) return n.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.",
+					);
+				};
+			Object.defineProperty(t, "__esModule", { value: !0 }),
+				(t.CONFIG = t.MathJax = t.Loader = void 0);
+			var o,
+				a = n(1),
+				i = n(2),
+				c = n(2);
+			Object.defineProperty(t, "Package", {
+				enumerable: !0,
+				get: function () {
+					return c.Package;
+				},
+			}),
+				Object.defineProperty(t, "PackageError", {
+					enumerable: !0,
+					get: function () {
+						return c.PackageError;
+					},
+				}),
+				(function (n) {
+					(n.ready = function () {
+						for (var e, t, n = [], o = 0; o < arguments.length; o++)
+							n[o] = arguments[o];
+						0 === n.length && (n = Array.from(i.Package.packages.keys()));
+						var a = [];
+						try {
+							for (var c = r(n), s = c.next(); !s.done; s = c.next()) {
+								var u = s.value,
+									l = i.Package.packages.get(u) || new i.Package(u, !0);
+								a.push(l.promise);
+							}
+						} catch (t) {
+							e = { error: t };
+						} finally {
+							try {
+								s && !s.done && (t = c.return) && t.call(c);
+							} finally {
+								if (e) throw e.error;
+							}
+						}
+						return Promise.all(a);
+					}),
+						(n.load = function () {
+							for (var e, n, o = [], a = 0; a < arguments.length; a++)
+								o[a] = arguments[a];
+							if (0 === o.length) return Promise.resolve();
+							var c = [];
+							try {
+								for (var s = r(o), u = s.next(); !u.done; u = s.next()) {
+									var l = u.value,
+										d = i.Package.packages.get(l);
+									d || (d = new i.Package(l)).provides(t.CONFIG.provides[l]),
+										d.checkNoLoad(),
+										c.push(d.promise);
+								}
+							} catch (t) {
+								e = { error: t };
+							} finally {
+								try {
+									u && !u.done && (n = s.return) && n.call(s);
+								} finally {
+									if (e) throw e.error;
+								}
+							}
+							return i.Package.loadAll(), Promise.all(c);
+						}),
+						(n.preLoad = function () {
+							for (var e, n, o = [], a = 0; a < arguments.length; a++)
+								o[a] = arguments[a];
+							try {
+								for (var c = r(o), s = c.next(); !s.done; s = c.next()) {
+									var u = s.value,
+										l = i.Package.packages.get(u);
+									l ||
+										(l = new i.Package(u, !0)).provides(t.CONFIG.provides[u]),
+										l.loaded();
+								}
+							} catch (t) {
+								e = { error: t };
+							} finally {
+								try {
+									s && !s.done && (n = c.return) && n.call(c);
+								} finally {
+									if (e) throw e.error;
+								}
+							}
+						}),
+						(n.defaultReady = function () {
+							void 0 !== t.MathJax.startup && t.MathJax.config.startup.ready();
+						}),
+						(n.getRoot = function () {
+							var t = e + "/../../es5";
+							if ("undefined" != typeof document) {
+								var n =
+									document.currentScript ||
+									document.getElementById("MathJax-script");
+								n && (t = n.src.replace(/\/[^\/]*$/, ""));
+							}
+							return t;
+						});
+				})((o = t.Loader || (t.Loader = {}))),
+				(t.MathJax = a.MathJax),
+				void 0 === t.MathJax.loader &&
+					(a.combineDefaults(t.MathJax.config, "loader", {
+						paths: { mathjax: o.getRoot() },
+						source: {},
+						dependencies: {},
+						provides: {},
+						load: [],
+						ready: o.defaultReady.bind(o),
+						failed: function (e) {
+							return console.log(
+								"MathJax(" + (e.package || "?") + "): " + e.message,
+							);
+						},
+						require: null,
+					}),
+					a.combineWithMathJax({ loader: o })),
+				(t.CONFIG = t.MathJax.config.loader);
+		}).call(this, "/");
+	},
+	function (e, t, n) {
+		"use strict";
+		(function (e) {
+			var n =
+				(this && this.__values) ||
+				function (e) {
+					var t = "function" == typeof Symbol && Symbol.iterator,
+						n = t && e[t],
+						r = 0;
+					if (n) return n.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.",
+					);
+				};
+			function r(e) {
+				return "object" == typeof e && null !== e;
+			}
+			function o(e, t) {
+				var a, i;
+				try {
+					for (var c = n(Object.keys(t)), s = c.next(); !s.done; s = c.next()) {
+						var u = s.value;
+						"__esModule" !== u &&
+							(!r(e[u]) || !r(t[u]) || t[u] instanceof Promise
+								? null !== t[u] && void 0 !== t[u] && (e[u] = t[u])
+								: o(e[u], t[u]));
+					}
+				} catch (e) {
+					a = { error: e };
+				} finally {
+					try {
+						s && !s.done && (i = c.return) && i.call(c);
+					} finally {
+						if (a) throw a.error;
+					}
+				}
+				return e;
+			}
+			Object.defineProperty(t, "__esModule", { value: !0 }),
+				(t.MathJax =
+					t.combineWithMathJax =
+					t.combineDefaults =
+					t.combineConfig =
+					t.isObject =
+						void 0),
+				(t.isObject = r),
+				(t.combineConfig = o),
+				(t.combineDefaults = function e(t, o, a) {
+					var i, c;
+					t[o] || (t[o] = {}), (t = t[o]);
+					try {
+						for (
+							var s = n(Object.keys(a)), u = s.next();
+							!u.done;
+							u = s.next()
+						) {
+							var l = u.value;
+							r(t[l]) && r(a[l])
+								? e(t, l, a[l])
+								: null == t[l] && null != a[l] && (t[l] = a[l]);
+						}
+					} catch (e) {
+						i = { error: e };
+					} finally {
+						try {
+							u && !u.done && (c = s.return) && c.call(s);
+						} finally {
+							if (i) throw i.error;
+						}
+					}
+					return t;
+				}),
+				(t.combineWithMathJax = function (e) {
+					return o(t.MathJax, e);
+				}),
+				void 0 === e.MathJax && (e.MathJax = {}),
+				e.MathJax.version ||
+					(e.MathJax = { version: "3.1.2", _: {}, config: e.MathJax }),
+				(t.MathJax = e.MathJax);
+		}).call(this, n(3));
+	},
+	function (e, t, n) {
+		"use strict";
+		var r,
+			o =
+				(this && this.__extends) ||
+				((r = function (e, t) {
+					return (r =
+						Object.setPrototypeOf ||
+						({ __proto__: [] } instanceof Array &&
+							function (e, t) {
+								e.__proto__ = t;
+							}) ||
+						function (e, t) {
+							for (var n in t) t.hasOwnProperty(n) && (e[n] = t[n]);
+						})(e, t);
+				}),
+				function (e, t) {
+					function n() {
+						this.constructor = e;
+					}
+					r(e, t),
+						(e.prototype =
+							null === t
+								? Object.create(t)
+								: ((n.prototype = t.prototype), new n()));
+				}),
+			a =
+				(this && this.__values) ||
+				function (e) {
+					var t = "function" == typeof Symbol && Symbol.iterator,
+						n = t && e[t],
+						r = 0;
+					if (n) return n.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.",
+					);
+				},
+			i =
+				(this && this.__read) ||
+				function (e, t) {
+					var n = "function" == typeof Symbol && e[Symbol.iterator];
+					if (!n) return e;
+					var r,
+						o,
+						a = n.call(e),
+						i = [];
+					try {
+						for (; (void 0 === t || t-- > 0) && !(r = a.next()).done; )
+							i.push(r.value);
+					} catch (e) {
+						o = { error: e };
+					} finally {
+						try {
+							r && !r.done && (n = a.return) && n.call(a);
+						} finally {
+							if (o) throw o.error;
+						}
+					}
+					return i;
+				},
+			c =
+				(this && this.__spread) ||
+				function () {
+					for (var e = [], t = 0; t < arguments.length; t++)
+						e = e.concat(i(arguments[t]));
+					return e;
+				};
+		Object.defineProperty(t, "__esModule", { value: !0 }),
+			(t.Package = t.PackageError = void 0);
+		var s = n(0),
+			u = (function (e) {
+				function t(t, n) {
+					var r = e.call(this, t) || this;
+					return (r.package = n), r;
+				}
+				return o(t, e), t;
+			})(Error);
+		t.PackageError = u;
+		var l = (function () {
+			function e(t, n) {
+				void 0 === n && (n = !1),
+					(this.isLoaded = !1),
+					(this.isLoading = !1),
+					(this.hasFailed = !1),
+					(this.dependents = []),
+					(this.dependencies = []),
+					(this.dependencyCount = 0),
+					(this.provided = []),
+					(this.name = t),
+					(this.noLoad = n),
+					e.packages.set(t, this),
+					(this.promise = this.makePromise(this.makeDependencies()));
+			}
+			return (
+				Object.defineProperty(e.prototype, "canLoad", {
+					get: function () {
+						return (
+							0 === this.dependencyCount &&
+							!this.noLoad &&
+							!this.isLoading &&
+							!this.hasFailed
+						);
+					},
+					enumerable: !1,
+					configurable: !0,
+				}),
+				(e.resolvePath = function (e, t) {
+					void 0 === t && (t = !0);
+					var n,
+						r = s.CONFIG.source[e] || e;
+					for (
+						r.match(/^(?:[a-z]+:\/)?\/|[a-z]:\\|\[/i) ||
+							(r = "[mathjax]/" + r.replace(/^\.\//, "")),
+							t && !r.match(/\.[^\/]+$/) && (r += ".js");
+						(n = r.match(/^\[([^\]]*)\]/)) &&
+						s.CONFIG.paths.hasOwnProperty(n[1]);
+					)
+						r = s.CONFIG.paths[n[1]] + r.substr(n[0].length);
+					return r;
+				}),
+				(e.loadAll = function () {
+					var e, t;
+					try {
+						for (
+							var n = a(this.packages.values()), r = n.next();
+							!r.done;
+							r = n.next()
+						) {
+							var o = r.value;
+							o.canLoad && o.load();
+						}
+					} catch (t) {
+						e = { error: t };
+					} finally {
+						try {
+							r && !r.done && (t = n.return) && t.call(n);
+						} finally {
+							if (e) throw e.error;
+						}
+					}
+				}),
+				(e.prototype.makeDependencies = function () {
+					var t,
+						n,
+						r = [],
+						o = e.packages,
+						i = this.noLoad,
+						u = this.name,
+						l = [];
+					s.CONFIG.dependencies.hasOwnProperty(u)
+						? l.push.apply(l, c(s.CONFIG.dependencies[u]))
+						: "core" !== u && l.push("core");
+					try {
+						for (var d = a(l), f = d.next(); !f.done; f = d.next()) {
+							var h = f.value,
+								p = o.get(h) || new e(h, i);
+							this.dependencies.indexOf(p) < 0 &&
+								(p.addDependent(this, i),
+								this.dependencies.push(p),
+								p.isLoaded || (this.dependencyCount++, r.push(p.promise)));
+						}
+					} catch (e) {
+						t = { error: e };
+					} finally {
+						try {
+							f && !f.done && (n = d.return) && n.call(d);
+						} finally {
+							if (t) throw t.error;
+						}
+					}
+					return r;
+				}),
+				(e.prototype.makePromise = function (e) {
+					var t = this,
+						n = new Promise(function (e, n) {
+							(t.resolve = e), (t.reject = n);
+						}),
+						r = s.CONFIG[this.name] || {};
+					return (
+						r.ready &&
+							(n = n.then(function (e) {
+								return r.ready(t.name);
+							})),
+						e.length &&
+							(e.push(n),
+							(n = Promise.all(e).then(function (e) {
+								return e.join(", ");
+							}))),
+						r.failed &&
+							n.catch(function (e) {
+								return r.failed(new u(e, t.name));
+							}),
+						n
+					);
+				}),
+				(e.prototype.load = function () {
+					if (!this.isLoaded && !this.isLoading && !this.noLoad) {
+						this.isLoading = !0;
+						var t = e.resolvePath(this.name);
+						s.CONFIG.require ? this.loadCustom(t) : this.loadScript(t);
+					}
+				}),
+				(e.prototype.loadCustom = function (e) {
+					var t = this;
+					try {
+						var n = s.CONFIG.require(e);
+						n instanceof Promise
+							? n
+									.then(function () {
+										return t.checkLoad();
+									})
+									.catch(function (n) {
+										return t.failed(
+											"Can't load \"" + e + '"\n' + n.message.trim(),
+										);
+									})
+							: this.checkLoad();
+					} catch (e) {
+						this.failed(e.message);
+					}
+				}),
+				(e.prototype.loadScript = function (e) {
+					var t = this,
+						n = document.createElement("script");
+					(n.src = e),
+						(n.charset = "UTF-8"),
+						(n.onload = function (e) {
+							return t.checkLoad();
+						}),
+						(n.onerror = function (n) {
+							return t.failed("Can't load \"" + e + '"');
+						}),
+						document.head.appendChild(n);
+				}),
+				(e.prototype.loaded = function () {
+					var e, t, n, r;
+					(this.isLoaded = !0), (this.isLoading = !1);
+					try {
+						for (
+							var o = a(this.dependents), i = o.next();
+							!i.done;
+							i = o.next()
+						) {
+							i.value.requirementSatisfied();
+						}
+					} catch (t) {
+						e = { error: t };
+					} finally {
+						try {
+							i && !i.done && (t = o.return) && t.call(o);
+						} finally {
+							if (e) throw e.error;
+						}
+					}
+					try {
+						for (
+							var c = a(this.provided), s = c.next();
+							!s.done;
+							s = c.next()
+						) {
+							s.value.loaded();
+						}
+					} catch (e) {
+						n = { error: e };
+					} finally {
+						try {
+							s && !s.done && (r = c.return) && r.call(c);
+						} finally {
+							if (n) throw n.error;
+						}
+					}
+					this.resolve(this.name);
+				}),
+				(e.prototype.failed = function (e) {
+					(this.hasFailed = !0),
+						(this.isLoading = !1),
+						this.reject(new u(e, this.name));
+				}),
+				(e.prototype.checkLoad = function () {
+					var e = this;
+					(
+						(s.CONFIG[this.name] || {}).checkReady ||
+						function () {
+							return Promise.resolve();
+						}
+					)()
+						.then(function () {
+							return e.loaded();
+						})
+						.catch(function (t) {
+							return e.failed(t);
+						});
+				}),
+				(e.prototype.requirementSatisfied = function () {
+					this.dependencyCount &&
+						(this.dependencyCount--, this.canLoad && this.load());
+				}),
+				(e.prototype.provides = function (t) {
+					var n, r;
+					void 0 === t && (t = []);
+					try {
+						for (var o = a(t), i = o.next(); !i.done; i = o.next()) {
+							var c = i.value,
+								u = e.packages.get(c);
+							u ||
+								(s.CONFIG.dependencies[c] || (s.CONFIG.dependencies[c] = []),
+								s.CONFIG.dependencies[c].push(c),
+								((u = new e(c, !0)).isLoading = !0)),
+								this.provided.push(u);
+						}
+					} catch (e) {
+						n = { error: e };
+					} finally {
+						try {
+							i && !i.done && (r = o.return) && r.call(o);
+						} finally {
+							if (n) throw n.error;
+						}
+					}
+				}),
+				(e.prototype.addDependent = function (e, t) {
+					this.dependents.push(e), t || this.checkNoLoad();
+				}),
+				(e.prototype.checkNoLoad = function () {
+					var e, t;
+					if (this.noLoad) {
+						this.noLoad = !1;
+						try {
+							for (
+								var n = a(this.dependencies), r = n.next();
+								!r.done;
+								r = n.next()
+							) {
+								r.value.checkNoLoad();
+							}
+						} catch (t) {
+							e = { error: t };
+						} finally {
+							try {
+								r && !r.done && (t = n.return) && t.call(n);
+							} finally {
+								if (e) throw e.error;
+							}
+						}
+					}
+				}),
+				(e.packages = new Map()),
+				e
+			);
+		})();
+		t.Package = l;
+	},
+	function (e, t) {
+		var n;
+		n = (function () {
+			return this;
+		})();
+		try {
+			n = n || new Function("return this")();
+		} catch (e) {
+			"object" == typeof window && (n = window);
+		}
+		e.exports = n;
+	},
+	function (e, t, n) {
+		"use strict";
+		n.r(t);
+		var r = n(1),
+			o = n(0),
+			a = n(2);
+		Object(r.combineWithMathJax)({
+			_: { components: { loader: o, package: a } },
+		});
+		var i,
+			c = {
+				tex: "[mathjax]/input/tex/extensions",
+				sre:
+					"[mathjax]/sre/" +
+					("undefined" == typeof window ? "sre-node" : "sre_browser"),
+			},
+			s = [
+				"[tex]/action",
+				"[tex]/ams",
+				"[tex]/amscd",
+				"[tex]/bbox",
+				"[tex]/boldsymbol",
+				"[tex]/braket",
+				"[tex]/bussproofs",
+				"[tex]/cancel",
+				"[tex]/color",
+				"[tex]/configmacros",
+				"[tex]/enclose",
+				"[tex]/extpfeil",
+				"[tex]/html",
+				"[tex]/mhchem",
+				"[tex]/newcommand",
+				"[tex]/noerrors",
+				"[tex]/noundefined",
+				"[tex]/physics",
+				"[tex]/require",
+				"[tex]/tagformat",
+				"[tex]/textmacros",
+				"[tex]/unicode",
+				"[tex]/verb",
+			],
+			u = {
+				startup: ["loader"],
+				"input/tex": [
+					"input/tex-base",
+					"[tex]/ams",
+					"[tex]/newcommand",
+					"[tex]/noundefined",
+					"[tex]/require",
+					"[tex]/autoload",
+					"[tex]/configmacros",
+				],
+				"input/tex-full": ["input/tex-base", "[tex]/all-packages"].concat(s),
+				"[tex]/all-packages": s,
+			};
+		function l(e, t) {
+			(null == t || t > e.length) && (t = e.length);
+			for (var n = 0, r = new Array(t); n < t; n++) r[n] = e[n];
+			return r;
+		}
+		Object(r.combineDefaults)(MathJax.config.loader, "dependencies", {
+			"a11y/semantic-enrich": ["input/mml", "[sre]"],
+			"a11y/complexity": ["a11y/semantic-enrich"],
+			"a11y/explorer": ["a11y/semantic-enrich", "ui/menu"],
+			"[tex]/all-packages": ["input/tex-base"],
+			"[tex]/action": ["input/tex-base", "[tex]/newcommand"],
+			"[tex]/autoload": ["input/tex-base", "[tex]/require"],
+			"[tex]/ams": ["input/tex-base"],
+			"[tex]/amscd": ["input/tex-base"],
+			"[tex]/bbox": ["input/tex-base", "[tex]/ams", "[tex]/newcommand"],
+			"[tex]/boldsymbol": ["input/tex-base"],
+			"[tex]/braket": ["input/tex-base"],
+			"[tex]/bussproofs": ["input/tex-base"],
+			"[tex]/cancel": ["input/tex-base", "[tex]/enclose"],
+			"[tex]/color": ["input/tex-base"],
+			"[tex]/colorv2": ["input/tex-base"],
+			"[tex]/configmacros": ["input/tex-base", "[tex]/newcommand"],
+			"[tex]/enclose": ["input/tex-base"],
+			"[tex]/extpfeil": ["input/tex-base", "[tex]/newcommand", "[tex]/ams"],
+			"[tex]/html": ["input/tex-base"],
+			"[tex]/mhchem": ["input/tex-base", "[tex]/ams"],
+			"[tex]/newcommand": ["input/tex-base"],
+			"[tex]/noerrors": ["input/tex-base"],
+			"[tex]/noundefined": ["input/tex-base"],
+			"[tex]/physics": ["input/tex-base"],
+			"[tex]/require": ["input/tex-base"],
+			"[tex]/tagformat": ["input/tex-base"],
+			"[tex]/textmacros": ["input/tex-base"],
+			"[tex]/unicode": ["input/tex-base"],
+			"[tex]/verb": ["input/tex-base"],
+		}),
+			Object(r.combineDefaults)(MathJax.config.loader, "paths", c),
+			Object(r.combineDefaults)(MathJax.config.loader, "provides", u),
+			o.Loader.load
+				.apply(
+					o.Loader,
+					((i = o.CONFIG.load),
+					(function (e) {
+						if (Array.isArray(e)) return l(e);
+					})(i) ||
+						(function (e) {
+							if ("undefined" != typeof Symbol && Symbol.iterator in Object(e))
+								return Array.from(e);
+						})(i) ||
+						(function (e, t) {
+							if (e) {
+								if ("string" == typeof e) return l(e, t);
+								var n = Object.prototype.toString.call(e).slice(8, -1);
+								return (
+									"Object" === n && e.constructor && (n = e.constructor.name),
+									"Map" === n || "Set" === n
+										? Array.from(e)
+										: "Arguments" === n ||
+												/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)
+											? l(e, t)
+											: void 0
+								);
+							}
+						})(i) ||
+						(function () {
+							throw new TypeError(
+								"Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.",
+							);
+						})()),
+				)
+				.then(function () {
+					return o.CONFIG.ready();
+				})
+				.catch(function (e, t) {
+					return o.CONFIG.failed(e, t);
+				});
+	},
+]);

assets/bower_components/MathJax/es5/sre/sre-node.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var SRE = require("speech-rule-engine");
+global.SRE = SRE;
+global.sre = Object.create(SRE);
+global.sre.Engine = {
+	isReady: function () {
+		return SRE.engineReady();
+	},
+};
+//# sourceMappingURL=sre-node.js.map

assets/bower_components/MathJax/es5/ui/safe.js

@@ -0,0 +1,636 @@
+!(function (t) {
+	var e = {};
+	function r(n) {
+		if (e[n]) return e[n].exports;
+		var i = (e[n] = { i: n, l: !1, exports: {} });
+		return t[n].call(i.exports, i, i.exports, r), (i.l = !0), i.exports;
+	}
+	(r.m = t),
+		(r.c = e),
+		(r.d = function (t, e, n) {
+			r.o(t, e) || Object.defineProperty(t, e, { enumerable: !0, get: n });
+		}),
+		(r.r = function (t) {
+			"undefined" != typeof Symbol &&
+				Symbol.toStringTag &&
+				Object.defineProperty(t, Symbol.toStringTag, { value: "Module" }),
+				Object.defineProperty(t, "__esModule", { value: !0 });
+		}),
+		(r.t = function (t, e) {
+			if ((1 & e && (t = r(t)), 8 & e)) return t;
+			if (4 & e && "object" == typeof t && t && t.__esModule) return t;
+			var n = Object.create(null);
+			if (
+				(r.r(n),
+				Object.defineProperty(n, "default", { enumerable: !0, value: t }),
+				2 & e && "string" != typeof t)
+			)
+				for (var i in t)
+					r.d(
+						n,
+						i,
+						function (e) {
+							return t[e];
+						}.bind(null, i),
+					);
+			return n;
+		}),
+		(r.n = function (t) {
+			var e =
+				t && t.__esModule
+					? function () {
+							return t.default;
+						}
+					: function () {
+							return t;
+						};
+			return r.d(e, "a", e), e;
+		}),
+		(r.o = function (t, e) {
+			return Object.prototype.hasOwnProperty.call(t, e);
+		}),
+		(r.p = ""),
+		r((r.s = 6));
+})([
+	function (t, e, r) {
+		"use strict";
+		var n,
+			i =
+				(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 r in e) e.hasOwnProperty(r) && (t[r] = e[r]);
+						})(t, e);
+				}),
+				function (t, e) {
+					function r() {
+						this.constructor = t;
+					}
+					n(t, e),
+						(t.prototype =
+							null === e
+								? Object.create(e)
+								: ((r.prototype = e.prototype), new r()));
+				}),
+			a =
+				(this && this.__assign) ||
+				function () {
+					return (a =
+						Object.assign ||
+						function (t) {
+							for (var e, r = 1, n = arguments.length; r < n; r++)
+								for (var i in (e = arguments[r]))
+									Object.prototype.hasOwnProperty.call(e, i) && (t[i] = e[i]);
+							return t;
+						}).apply(this, arguments);
+				},
+			o =
+				(this && this.__read) ||
+				function (t, e) {
+					var r = "function" == typeof Symbol && t[Symbol.iterator];
+					if (!r) return t;
+					var n,
+						i,
+						a = r.call(t),
+						o = [];
+					try {
+						for (; (void 0 === e || e-- > 0) && !(n = a.next()).done; )
+							o.push(n.value);
+					} catch (t) {
+						i = { error: t };
+					} finally {
+						try {
+							n && !n.done && (r = a.return) && r.call(a);
+						} finally {
+							if (i) throw i.error;
+						}
+					}
+					return o;
+				},
+			l =
+				(this && this.__spread) ||
+				function () {
+					for (var t = [], e = 0; e < arguments.length; e++)
+						t = t.concat(o(arguments[e]));
+					return t;
+				},
+			s =
+				(this && this.__values) ||
+				function (t) {
+					var e = "function" == typeof Symbol && Symbol.iterator,
+						r = e && t[e],
+						n = 0;
+					if (r) return r.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.SafeHandler = e.SafeMathDocumentMixin = void 0);
+		var u = r(1);
+		function f(t) {
+			var e;
+			return (
+				((e = (function (t) {
+					function e() {
+						for (var e, r, n = [], i = 0; i < arguments.length; i++)
+							n[i] = arguments[i];
+						var a = t.apply(this, l(n)) || this;
+						a.safe = new a.options.SafeClass(a, a.options.safeOptions);
+						var o = a.constructor.ProcessBits;
+						o.has("safe") || o.allocate("safe");
+						try {
+							for (var u = s(a.inputJax), f = u.next(); !f.done; f = u.next()) {
+								var c = f.value;
+								c.name.match(/MathML/)
+									? ((c.mathml.filterAttribute = a.safe.mmlAttribute.bind(
+											a.safe,
+										)),
+										(c.mathml.filterClassList = a.safe.mmlClassList.bind(
+											a.safe,
+										)))
+									: c.name.match(/TeX/) &&
+										c.postFilters.add(a.sanitize.bind(c), -5.5);
+							}
+						} catch (t) {
+							e = { error: t };
+						} finally {
+							try {
+								f && !f.done && (r = u.return) && r.call(u);
+							} finally {
+								if (e) throw e.error;
+							}
+						}
+						return a;
+					}
+					return (
+						i(e, t),
+						(e.prototype.sanitize = function (t) {
+							(t.math.root = this.parseOptions.root),
+								t.document.safe.sanitize(t.math, t.document);
+						}),
+						e
+					);
+				})(t)).OPTIONS = a(a({}, t.OPTIONS), {
+					safeOptions: a({}, u.Safe.OPTIONS),
+					SafeClass: u.Safe,
+				})),
+				e
+			);
+		}
+		(e.SafeMathDocumentMixin = f),
+			(e.SafeHandler = function (t) {
+				return (t.documentClass = f(t.documentClass)), t;
+			});
+	},
+	function (t, e, r) {
+		"use strict";
+		var n =
+				(this && this.__assign) ||
+				function () {
+					return (n =
+						Object.assign ||
+						function (t) {
+							for (var e, r = 1, n = arguments.length; r < n; r++)
+								for (var i in (e = arguments[r]))
+									Object.prototype.hasOwnProperty.call(e, i) && (t[i] = e[i]);
+							return t;
+						}).apply(this, arguments);
+				},
+			i =
+				(this && this.__values) ||
+				function (t) {
+					var e = "function" == typeof Symbol && Symbol.iterator,
+						r = e && t[e],
+						n = 0;
+					if (r) return r.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.Safe = void 0);
+		var a = r(4),
+			o = r(2),
+			l = (function () {
+				function t(t, e) {
+					(this.filterAttributes = new Map([
+						["href", "filterURL"],
+						["src", "filterURL"],
+						["altimg", "filterURL"],
+						["class", "filterClassList"],
+						["style", "filterStyles"],
+						["id", "filterID"],
+						["fontsize", "filterFontSize"],
+						["mathsize", "filterFontSize"],
+						["scriptminsize", "filterFontSize"],
+						["scriptsizemultiplier", "filterSizeMultiplier"],
+						["scriptlevel", "filterScriptLevel"],
+						["data-", "filterData"],
+					])),
+						(this.filterMethods = n({}, o.SafeMethods)),
+						(this.adaptor = t.adaptor),
+						(this.options = e),
+						(this.allow = this.options.allow);
+				}
+				return (
+					(t.prototype.sanitize = function (t, e) {
+						try {
+							t.root.walkTree(this.sanitizeNode.bind(this));
+						} catch (r) {
+							e.options.compileError(e, t, r);
+						}
+					}),
+					(t.prototype.sanitizeNode = function (t) {
+						var e,
+							r,
+							n = t.attributes.getAllAttributes();
+						try {
+							for (
+								var a = i(Object.keys(n)), o = a.next();
+								!o.done;
+								o = a.next()
+							) {
+								var l = o.value,
+									s = this.filterAttributes.get(l);
+								if (s) {
+									var u = this.filterMethods[s](this, n[l]);
+									u
+										? u !== ("number" == typeof u ? parseFloat(n[l]) : n[l]) &&
+											(n[l] = u)
+										: delete n[l];
+								}
+							}
+						} catch (t) {
+							e = { error: t };
+						} finally {
+							try {
+								o && !o.done && (r = a.return) && r.call(a);
+							} finally {
+								if (e) throw e.error;
+							}
+						}
+					}),
+					(t.prototype.mmlAttribute = function (t, e) {
+						if ("class" === t) return null;
+						var r =
+							this.filterAttributes.get(t) ||
+							("data-" === t.substr(0, 5)
+								? this.filterAttributes.get("data-")
+								: null);
+						if (!r) return e;
+						var n = this.filterMethods[r](this, e, t);
+						return "number" == typeof n || "boolean" == typeof n
+							? String(n)
+							: n;
+					}),
+					(t.prototype.mmlClassList = function (t) {
+						var e = this;
+						return t
+							.map(function (t) {
+								return e.filterMethods.filterClass(e, t);
+							})
+							.filter(function (t) {
+								return null !== t;
+							});
+					}),
+					(t.OPTIONS = {
+						allow: {
+							URLs: "safe",
+							classes: "safe",
+							cssIDs: "safe",
+							styles: "safe",
+						},
+						lengthMax: 3,
+						scriptsizemultiplierRange: [0.6, 1],
+						scriptlevelRange: [-2, 2],
+						classPattern: /^mjx-[-a-zA-Z0-9_.]+$/,
+						idPattern: /^mjx-[-a-zA-Z0-9_.]+$/,
+						dataPattern: /^data-mjx-/,
+						safeProtocols: a.expandable({
+							http: !0,
+							https: !0,
+							file: !0,
+							javascript: !1,
+							data: !1,
+						}),
+						safeStyles: a.expandable({
+							color: !0,
+							backgroundColor: !0,
+							border: !0,
+							cursor: !0,
+							margin: !0,
+							padding: !0,
+							textShadow: !0,
+							fontFamily: !0,
+							fontSize: !0,
+							fontStyle: !0,
+							fontWeight: !0,
+							opacity: !0,
+							outline: !0,
+						}),
+						styleParts: a.expandable({
+							border: !0,
+							padding: !0,
+							margin: !0,
+							outline: !0,
+						}),
+						styleLengths: a.expandable({
+							borderTop: "borderTopWidth",
+							borderRight: "borderRightWidth",
+							borderBottom: "borderBottomWidth",
+							borderLeft: "borderLeftWidth",
+							paddingTop: !0,
+							paddingRight: !0,
+							paddingBottom: !0,
+							paddingLeft: !0,
+							marginTop: !0,
+							marginRight: !0,
+							marginBottom: !0,
+							marginLeft: !0,
+							outlineTop: !0,
+							outlineRight: !0,
+							outlineBottom: !0,
+							outlineLeft: !0,
+							fontSize: [0.707, 1.44],
+						}),
+					}),
+					t
+				);
+			})();
+		e.Safe = l;
+	},
+	function (t, e, r) {
+		"use strict";
+		var n =
+				(this && this.__values) ||
+				function (t) {
+					var e = "function" == typeof Symbol && Symbol.iterator,
+						r = e && t[e],
+						n = 0;
+					if (r) return r.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.",
+					);
+				},
+			i =
+				(this && this.__read) ||
+				function (t, e) {
+					var r = "function" == typeof Symbol && t[Symbol.iterator];
+					if (!r) return t;
+					var n,
+						i,
+						a = r.call(t),
+						o = [];
+					try {
+						for (; (void 0 === e || e-- > 0) && !(n = a.next()).done; )
+							o.push(n.value);
+					} catch (t) {
+						i = { error: t };
+					} finally {
+						try {
+							n && !n.done && (r = a.return) && r.call(a);
+						} finally {
+							if (i) throw i.error;
+						}
+					}
+					return o;
+				};
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.SafeMethods = void 0);
+		var a = r(5);
+		e.SafeMethods = {
+			filterURL: function (t, e) {
+				var r = (e.match(/^\s*([a-z]+):/i) || [null, ""])[1].toLowerCase(),
+					n = t.allow.URLs;
+				return "all" === n ||
+					("safe" === n && (t.options.safeProtocols[r] || !r))
+					? e
+					: null;
+			},
+			filterClassList: function (t, e) {
+				var r = this;
+				return e
+					.trim()
+					.replace(/\s\s+/g, " ")
+					.split(/ /)
+					.map(function (e) {
+						return r.filterClass(t, e) || "";
+					})
+					.join(" ")
+					.trim()
+					.replace(/\s\s+/g, "");
+			},
+			filterClass: function (t, e) {
+				var r = t.allow.classes;
+				return "all" === r || ("safe" === r && e.match(t.options.classPattern))
+					? e
+					: null;
+			},
+			filterID: function (t, e) {
+				var r = t.allow.cssIDs;
+				return "all" === r || ("safe" === r && e.match(t.options.idPattern))
+					? e
+					: null;
+			},
+			filterStyles: function (t, e) {
+				var r, i, a, o;
+				if ("all" === t.allow.styles) return e;
+				if ("safe" !== t.allow.styles) return null;
+				var l = t.adaptor,
+					s = t.options;
+				try {
+					var u = l.node("div", { style: e }),
+						f = l.node("div");
+					try {
+						for (
+							var c = n(Object.keys(s.safeStyles)), p = c.next();
+							!p.done;
+							p = c.next()
+						) {
+							var h = p.value;
+							if (s.styleParts[h])
+								try {
+									for (
+										var d =
+												((a = void 0), n(["Top", "Right", "Bottom", "Left"])),
+											y = d.next();
+										!y.done;
+										y = d.next()
+									) {
+										var m,
+											b = h + y.value;
+										(m = this.filterStyle(t, b, u)) && l.setStyle(f, b, m);
+									}
+								} catch (t) {
+									a = { error: t };
+								} finally {
+									try {
+										y && !y.done && (o = d.return) && o.call(d);
+									} finally {
+										if (a) throw a.error;
+									}
+								}
+							else (m = this.filterStyle(t, h, u)) && l.setStyle(f, h, m);
+						}
+					} catch (t) {
+						r = { error: t };
+					} finally {
+						try {
+							p && !p.done && (i = c.return) && i.call(c);
+						} finally {
+							if (r) throw r.error;
+						}
+					}
+					e = l.allStyles(f);
+				} catch (t) {
+					e = "";
+				}
+				return e;
+			},
+			filterStyle: function (t, e, r) {
+				var n = t.adaptor.getStyle(r, e);
+				if (
+					"string" != typeof n ||
+					"" === n ||
+					n.match(/^\s*calc/) ||
+					(n.match(/javascript:/) && !t.options.safeProtocols.javascript) ||
+					(n.match(/data:/) && !t.options.safeProtocols.data)
+				)
+					return null;
+				var i = e.replace(/Top|Right|Left|Bottom/, "");
+				return t.options.safeStyles[e] || t.options.safeStyles[i]
+					? this.filterStyleValue(t, e, n, r)
+					: null;
+			},
+			filterStyleValue: function (t, e, r, n) {
+				var i = t.options.styleLengths[e];
+				if (!i) return r;
+				if ("string" != typeof i) return this.filterStyleLength(t, e, r);
+				var a = this.filterStyleLength(t, i, t.adaptor.getStyle(n, i));
+				return a
+					? (t.adaptor.setStyle(n, i, a), t.adaptor.getStyle(n, e))
+					: null;
+			},
+			filterStyleLength: function (t, e, r) {
+				if (!r.match(/^(.+)(em|ex|ch|rem|px|mm|cm|in|pt|pc|%)$/)) return null;
+				var n = a.length2em(r, 1),
+					o = t.options.styleLengths[e],
+					l = i(
+						Array.isArray(o) ? o : [-t.options.lengthMax, t.options.lengthMax],
+						2,
+					),
+					s = l[0],
+					u = l[1];
+				return s <= n && n <= u
+					? r
+					: (n < s ? s : u).toFixed(3).replace(/\.?0+$/, "") + "em";
+			},
+			filterFontSize: function (t, e) {
+				return this.filterStyleLength(t, "fontSize", e);
+			},
+			filterSizeMultiplier: function (t, e) {
+				var r = i(t.options.scriptsizemultiplierRange || [-1 / 0, 1 / 0], 2),
+					n = r[0],
+					a = r[1];
+				return Math.min(a, Math.max(n, parseFloat(e)));
+			},
+			filterScriptLevel: function (t, e) {
+				var r = i(t.options.scriptlevelRange || [-1 / 0, 1 / 0], 2),
+					n = r[0],
+					a = r[1];
+				return Math.min(a, Math.max(n, parseInt(e)));
+			},
+			filterData: function (t, e, r) {
+				return r.match(t.options.dataPattern) ? e : null;
+			},
+		};
+	},
+	function (t, e, r) {
+		"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, r) {
+		"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, r) {
+		"use strict";
+		Object.defineProperty(e, "__esModule", { value: !0 }),
+			(e.BIGDIMEN = MathJax._.util.lengths.BIGDIMEN),
+			(e.UNITS = MathJax._.util.lengths.UNITS),
+			(e.RELUNITS = MathJax._.util.lengths.RELUNITS),
+			(e.MATHSPACE = MathJax._.util.lengths.MATHSPACE),
+			(e.length2em = MathJax._.util.lengths.length2em),
+			(e.percent = MathJax._.util.lengths.percent),
+			(e.em = MathJax._.util.lengths.em),
+			(e.emRounded = MathJax._.util.lengths.emRounded),
+			(e.px = MathJax._.util.lengths.px);
+	},
+	function (t, e, r) {
+		"use strict";
+		r.r(e);
+		var n = r(3),
+			i = r(0),
+			a = r(2),
+			o = r(1);
+		Object(n.combineWithMathJax)({
+			_: { ui: { safe: { SafeHandler: i, SafeMethods: a, safe: o } } },
+		}),
+			MathJax.startup &&
+				"undefined" != typeof window &&
+				MathJax.startup.extendHandler(function (t) {
+					return Object(i.SafeHandler)(t);
+				});
+	},
+]);

assets/bower_components/MathJax/package.json

@@ -0,0 +1,59 @@
+{
+	"name": "mathjax",
+	"version": "3.1.2",
+	"description": "Beautiful and accessible math in all browsers. MathJax is an open-source JavaScript display engine for LaTeX, MathML, and AsciiMath notation that works in all browsers. This package includes the packaged components (install mathjax-full to get the source code).",
+	"keywords": [
+		"math",
+		"svg",
+		"mathml",
+		"tex",
+		"latex",
+		"asciimath",
+		"browser",
+		"node"
+	],
+	"devDependencies": {
+		"mathjax-full": "3.1.2"
+	},
+	"maintainers": [
+		"MathJax Consortium <info@mathjax.org> (http://www.mathjax.org)"
+	],
+	"bugs": {
+		"url": "http://github.com/mathjax/MathJax/issues"
+	},
+	"license": "Apache-2.0",
+	"repository": {
+		"type": "git",
+		"url": "git://github.com/mathjax/MathJax.git"
+	},
+	"main": "es5/node-main.js",
+	"files": [
+		"/es5"
+	],
+	"scripts": {
+		"test": "echo 'No tests defined'",
+		"clean": "npm run --silent clean:es5 && npm run --silent clean:node",
+		"clean:es5": "rm -rf es5",
+		"clean:node": "rm -rf node_modules package-lock.json",
+		"message": "echo \"$(tput setaf 4)${npm_package_config_message}$(tput setaf 0)\" && echo",
+		"line": "echo '--------------------------------------------'",
+		"title": "npm run --silent line && npm run --silent message --mathjax:message=\"${npm_package_config_title}\"",
+		"preinstall:mj3": "npm run --silent title --mathjax:title='Installing MathJax...'",
+		"install:mj3": "npm install",
+		"preinstall:mj3-deps": "npm run --silent message --mathjax:message='Installing MathJax Dependencies...'",
+		"install:mj3-deps": "cd node_modules/mathjax-full && npm install",
+		"install:all": "npm run --silent install:mj3 && npm run --silent install:mj3-deps",
+		"precompile": "npm run --silent title --mathjax:title='Compiling MathJax...'",
+		"compile": "cd node_modules/mathjax-full && npm run --silent compile",
+		"precomponents": "npm run --silent title --mathjax:title='Building MathJax Components...'",
+		"components": "cd node_modules/mathjax-full && npm run --silent make-components",
+		"premove": "npm run --silent title --mathjax:title='Moving MathJax Components...'",
+		"move": "npm run --silent clean:es5 && mv node_modules/mathjax-full/es5 .",
+		"premake-es5": "npm run --silent clean:node",
+		"make-es5": "npm run --silent install:all && npm run --silent compile && npm run --silent components && npm run --silent move",
+		"postmake-es5": "npm run --silent title --mathjax:title='Cleaning Up...' && npm run --silent clean:node",
+		"preget-es5": "npm run --silent clean:node",
+		"get-es5": "npm run --silent install:mj3 && npm run --silent move",
+		"postget-es5": "npm run --silent title --mathjax:title='Cleaning Up...' && npm run --silent clean:node"
+	}
+}