!(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"));
	},
]);