manim-web 0.3.19 → 0.3.21

package/dist/ParseMethods-BMPfzfQC.js

@@ -0,0 +1,2636 @@
+import { o as e, r as t, t as n } from "./Options-XPptO-6X.js";
+import { o as r } from "./mathjax-CoSFlQ0H.js";
+import { n as i } from "./Styles-J-6R3Vr8.js";
+import { t as a } from "./Entities-B1o7gN0J.js";
+import { d as o, h as s, i as c, p as l, t as u, x as d } from "./mo-CNYDGAsg.js";
+import { r as f } from "./lengths-CP7zmbxJ.js";
+//#region node_modules/@mathjax/src/mjs/input/tex/NodeUtil.js
+var p = {
+	attrs: new Set([
+		"autoOP",
+		"fnOP",
+		"movesupsub",
+		"subsupOK",
+		"texprimestyle",
+		"useHeight",
+		"variantForm",
+		"withDelims",
+		"mathaccent",
+		"open",
+		"close"
+	]),
+	createEntity(e) {
+		return String.fromCodePoint(parseInt(e, 16));
+	},
+	getChildren(e) {
+		return e.childNodes;
+	},
+	getText(e) {
+		return e.getText();
+	},
+	appendChildren(e, t) {
+		for (let n of t) e.appendChild(n);
+	},
+	setAttribute(e, t, n) {
+		e.attributes.set(t, n);
+	},
+	setProperty(e, t, n) {
+		e.setProperty(t, n);
+	},
+	setProperties(e, t) {
+		for (let n of Object.keys(t)) {
+			let r = t[n];
+			n === "texClass" ? (e.texClass = r, e.setProperty(n, r)) : n === "movablelimits" ? (e.setProperty("movablelimits", r), (e.isKind("mo") || e.isKind("mstyle")) && e.attributes.set("movablelimits", r)) : n === "inferred" || (p.attrs.has(n) ? e.setProperty(n, r) : e.attributes.set(n, r));
+		}
+	},
+	getProperty(e, t) {
+		return e.getProperty(t);
+	},
+	getAttribute(e, t) {
+		return e.attributes.get(t);
+	},
+	removeAttribute(e, t) {
+		e.attributes.unset(t);
+	},
+	removeProperties(e, ...t) {
+		e.removeProperty(...t);
+	},
+	getChildAt(e, t) {
+		return e.childNodes[t];
+	},
+	setChild(e, t, n) {
+		let r = e.childNodes;
+		r[t] = n, n && (n.parent = e);
+	},
+	copyChildren(e, t) {
+		let n = e.childNodes;
+		for (let e = 0; e < n.length; e++) this.setChild(t, e, n[e]);
+	},
+	copyAttributes(e, t) {
+		t.attributes = e.attributes;
+		for (let [n, r] of Object.entries(e.getAllProperties())) t.setProperty(n, r);
+	},
+	isType(e, t) {
+		return e.isKind(t);
+	},
+	isEmbellished(e) {
+		return e.isEmbellished;
+	},
+	getTexClass(e) {
+		return e.texClass;
+	},
+	getCoreMO(e) {
+		return e.coreMO();
+	},
+	isNode(e) {
+		return e instanceof l || e instanceof o;
+	},
+	isInferred(e) {
+		return e.isInferred;
+	},
+	getForm(e) {
+		if (!e.isKind("mo")) return null;
+		let t = e, n = t.getForms();
+		for (let e of n) {
+			let n = this.getOp(t, e);
+			if (n) return n;
+		}
+		return null;
+	},
+	getOp(e, t = "infix") {
+		return u.OPTABLE[t][e.getText()] || null;
+	},
+	getMoAttribute(e, t) {
+		if (!e.attributes.isSet(t)) for (let n of [
+			"infix",
+			"postfix",
+			"prefix"
+		]) {
+			let r = this.getOp(e, n)?.[3]?.[t];
+			if (r !== void 0) return r;
+		}
+		return e.attributes.get(t);
+	}
+}, m = {
+	Variant: {
+		NORMAL: "normal",
+		BOLD: "bold",
+		ITALIC: "italic",
+		BOLDITALIC: "bold-italic",
+		DOUBLESTRUCK: "double-struck",
+		FRAKTUR: "fraktur",
+		BOLDFRAKTUR: "bold-fraktur",
+		SCRIPT: "script",
+		BOLDSCRIPT: "bold-script",
+		SANSSERIF: "sans-serif",
+		BOLDSANSSERIF: "bold-sans-serif",
+		SANSSERIFITALIC: "sans-serif-italic",
+		SANSSERIFBOLDITALIC: "sans-serif-bold-italic",
+		MONOSPACE: "monospace",
+		INITIAL: "inital",
+		TAILED: "tailed",
+		LOOPED: "looped",
+		STRETCHED: "stretched",
+		CALLIGRAPHIC: "-tex-calligraphic",
+		BOLDCALLIGRAPHIC: "-tex-bold-calligraphic",
+		OLDSTYLE: "-tex-oldstyle",
+		BOLDOLDSTYLE: "-tex-bold-oldstyle",
+		MATHITALIC: "-tex-mathit"
+	},
+	Form: {
+		PREFIX: "prefix",
+		INFIX: "infix",
+		POSTFIX: "postfix"
+	},
+	LineBreak: {
+		AUTO: "auto",
+		NEWLINE: "newline",
+		NOBREAK: "nobreak",
+		GOODBREAK: "goodbreak",
+		BADBREAK: "badbreak"
+	},
+	LineBreakStyle: {
+		BEFORE: "before",
+		AFTER: "after",
+		DUPLICATE: "duplicate",
+		INFIXLINBREAKSTYLE: "infixlinebreakstyle"
+	},
+	IndentAlign: {
+		LEFT: "left",
+		CENTER: "center",
+		RIGHT: "right",
+		AUTO: "auto",
+		ID: "id",
+		INDENTALIGN: "indentalign"
+	},
+	IndentShift: { INDENTSHIFT: "indentshift" },
+	LineThickness: {
+		THIN: "thin",
+		MEDIUM: "medium",
+		THICK: "thick"
+	},
+	Notation: {
+		LONGDIV: "longdiv",
+		ACTUARIAL: "actuarial",
+		PHASORANGLE: "phasorangle",
+		RADICAL: "radical",
+		BOX: "box",
+		ROUNDEDBOX: "roundedbox",
+		CIRCLE: "circle",
+		LEFT: "left",
+		RIGHT: "right",
+		TOP: "top",
+		BOTTOM: "bottom",
+		UPDIAGONALSTRIKE: "updiagonalstrike",
+		DOWNDIAGONALSTRIKE: "downdiagonalstrike",
+		VERTICALSTRIKE: "verticalstrike",
+		HORIZONTALSTRIKE: "horizontalstrike",
+		NORTHEASTARROW: "northeastarrow",
+		MADRUWB: "madruwb",
+		UPDIAGONALARROW: "updiagonalarrow"
+	},
+	Align: {
+		TOP: "top",
+		BOTTOM: "bottom",
+		CENTER: "center",
+		BASELINE: "baseline",
+		AXIS: "axis",
+		LEFT: "left",
+		RIGHT: "right"
+	},
+	Lines: {
+		NONE: "none",
+		SOLID: "solid",
+		DASHED: "dashed"
+	},
+	Side: {
+		LEFT: "left",
+		RIGHT: "right",
+		LEFTOVERLAP: "leftoverlap",
+		RIGHTOVERLAP: "rightoverlap"
+	},
+	Width: {
+		AUTO: "auto",
+		FIT: "fit"
+	},
+	Actiontype: {
+		TOGGLE: "toggle",
+		STATUSLINE: "statusline",
+		TOOLTIP: "tooltip",
+		INPUT: "input"
+	},
+	Overflow: {
+		LINBREAK: "linebreak",
+		SCROLL: "scroll",
+		ELIDE: "elide",
+		TRUNCATE: "truncate",
+		SCALE: "scale"
+	},
+	Unit: {
+		EM: "em",
+		EX: "ex",
+		PX: "px",
+		IN: "in",
+		CM: "cm",
+		MM: "mm",
+		PT: "pt",
+		PC: "pc"
+	},
+	Attr: {
+		LATEX: "data-latex",
+		LATEXITEM: "data-latex-item"
+	}
+}, h;
+(function(e) {
+	e.HANDLER = "handler", e.FALLBACK = "fallback", e.ITEMS = "items", e.TAGS = "tags", e.OPTIONS = "options", e.NODES = "nodes", e.PREPROCESSORS = "preprocessors", e.POSTPROCESSORS = "postprocessors", e.INIT = "init", e.CONFIG = "config", e.PRIORITY = "priority", e.PARSER = "parser";
+})(h ||= {});
+var g;
+(function(e) {
+	e.DELIMITER = "delimiter", e.MACRO = "macro", e.CHARACTER = "character", e.ENVIRONMENT = "environment";
+})(g ||= {});
+//#endregion
+//#region node_modules/@mathjax/src/mjs/input/tex/UnitUtil.js
+var ee = class {
+	constructor(e) {
+		this.num = "([-+]?([.,]\\d+|\\d+([.,]\\d*)?))", this.unit = "", this.dimenEnd = /./, this.dimenRest = /./, this.map = new Map(e), this.updateDimen();
+	}
+	updateDimen() {
+		this.unit = `(${Array.from(this.map.keys()).join("|")})`, this.dimenEnd = RegExp("^\\s*" + this.num + "\\s*" + this.unit + "\\s*$"), this.dimenRest = RegExp("^\\s*" + this.num + "\\s*" + this.unit + " ?");
+	}
+	set(e, t) {
+		return this.map.set(e, t), this.updateDimen(), this;
+	}
+	get(e) {
+		return this.map.get(e) || this.map.get("pt");
+	}
+	delete(e) {
+		return this.map.delete(e) ? (this.updateDimen(), !0) : !1;
+	}
+}, _ = 7.2, te = 72;
+function ne([e, t, n]) {
+	return t === "mu" ? [
+		v.em(v.UNIT_CASES.get(t) * parseFloat(e)).slice(0, -2),
+		"em",
+		n
+	] : [
+		e,
+		t,
+		n
+	];
+}
+var v = {
+	UNIT_CASES: new ee([
+		["em", 1],
+		["ex", .43],
+		["pt", 1 / 10],
+		["pc", 1.2],
+		["px", _ / te],
+		["in", _],
+		["cm", _ / 2.54],
+		["mm", _ / 25.4],
+		["mu", 1 / 18]
+	]),
+	matchDimen(e, t = !1) {
+		let n = e.match(t ? v.UNIT_CASES.dimenRest : v.UNIT_CASES.dimenEnd);
+		return n ? ne([
+			n[1].replace(/,/, "."),
+			n[4],
+			n[0].length
+		]) : [
+			null,
+			null,
+			0
+		];
+	},
+	dimen2em(e) {
+		let [t, n] = v.matchDimen(e), r = parseFloat(t || "1");
+		return v.UNIT_CASES.get(n) * r;
+	},
+	em(e) {
+		return Math.abs(e) < 6e-4 ? "0em" : e.toFixed(3).replace(/\.?0+$/, "") + "em";
+	},
+	trimSpaces(e) {
+		if (typeof e != "string") return e;
+		let t = e.trim();
+		return t.match(/\\$/) && e.match(/ $/) && (t += " "), t;
+	}
+}, re = class {
+	constructor(e, t, n) {
+		this._factory = e, this._env = t, this.global = {}, this.stack = [], this.global = { isInner: n }, this.stack = [this._factory.create("start", this.global)], t && (this.stack[0].env = t), this.env = this.stack[0].env;
+	}
+	set env(e) {
+		this._env = e;
+	}
+	get env() {
+		return this._env;
+	}
+	Push(...e) {
+		for (let t of e) {
+			if (!t) continue;
+			let e = p.isNode(t) ? this._factory.create("mml", t) : t;
+			e.global = this.global;
+			let [n, r] = this.stack.length ? this.Top().checkItem(e) : [null, !0];
+			if (r) {
+				if (n) {
+					this.Pop(), this.Push(...n);
+					continue;
+				}
+				e.isKind("null") || this.stack.push(e), e.env ? (e.copyEnv && Object.assign(e.env, this.env), this.env = e.env) : e.env = this.env;
+			}
+		}
+	}
+	Pop() {
+		let e = this.stack.pop();
+		return e.isOpen || delete e.env, this.env = this.stack.length ? this.Top().env : {}, e;
+	}
+	Top(e = 1) {
+		return this.stack.length < e ? null : this.stack[this.stack.length - e];
+	}
+	Prev(e) {
+		let t = this.Top();
+		return e ? t.First : t.Pop();
+	}
+	get height() {
+		return this.stack.length;
+	}
+	toString() {
+		return "stack[\n  " + this.stack.join("\n  ") + "\n]";
+	}
+}, y = class e {
+	static processString(t, n) {
+		let r = t.split(e.pattern);
+		for (let e = 1, t = r.length; e < t; e += 2) {
+			let t = r[e].charAt(0);
+			t >= "0" && t <= "9" ? (r[e] = n[parseInt(r[e], 10) - 1], typeof r[e] == "number" && (r[e] = r[e].toString())) : t === "{" && (t = r[e].substring(1), t >= "0" && t <= "9" ? (r[e] = n[parseInt(r[e].substring(1, r[e].length - 1), 10) - 1], typeof r[e] == "number" && (r[e] = r[e].toString())) : r[e].match(/^\{([a-z]+):%(\d+)\|(.*)\}$/) && (r[e] = "%" + r[e]));
+		}
+		return r.join("");
+	}
+	constructor(t, n, ...r) {
+		this.id = t, this.message = e.processString(n, r);
+	}
+};
+y.pattern = /%(\d+|\{\d+\}|\{[a-z]+:%\d+(?:\|(?:%\{\d+\}|%.|[^}])*)+\}|.)/g;
+//#endregion
+//#region node_modules/@mathjax/src/mjs/input/tex/StackItem.js
+var ie = class {
+	constructor(e) {
+		this._nodes = e, this.startStr = "", this.startI = 0, this.stopI = 0;
+	}
+	get nodes() {
+		return this._nodes;
+	}
+	Push(...e) {
+		this._nodes.push(...e);
+	}
+	Pop() {
+		return this._nodes.pop();
+	}
+	get First() {
+		return this._nodes[this.Size() - 1];
+	}
+	set First(e) {
+		this._nodes[this.Size() - 1] = e;
+	}
+	get Last() {
+		return this._nodes[0];
+	}
+	set Last(e) {
+		this._nodes[0] = e;
+	}
+	Peek(e) {
+		return e ??= 1, this._nodes.slice(this.Size() - e);
+	}
+	Size() {
+		return this._nodes.length;
+	}
+	Clear() {
+		this._nodes = [];
+	}
+	toMml(e = !0, t) {
+		return this._nodes.length === 1 && !t ? this.First : this.create("node", e ? "inferredMrow" : "mrow", this._nodes, {});
+	}
+	create(e, ...t) {
+		return this.factory.configuration.nodeFactory.create(e, ...t);
+	}
+}, b = class e extends ie {
+	constructor(e, ...t) {
+		super(t), this.factory = e, this.global = {}, this._properties = {}, this.isOpen && (this._env = {});
+	}
+	get kind() {
+		return "base";
+	}
+	get env() {
+		return this._env;
+	}
+	set env(e) {
+		this._env = e;
+	}
+	get copyEnv() {
+		return !0;
+	}
+	getProperty(e) {
+		return this._properties[e];
+	}
+	setProperty(e, t) {
+		return this._properties[e] = t, this;
+	}
+	get isOpen() {
+		return !1;
+	}
+	get isClose() {
+		return !1;
+	}
+	get isFinal() {
+		return !1;
+	}
+	isKind(e) {
+		return e === this.kind;
+	}
+	checkItem(t) {
+		if (t.isKind("over") && this.isOpen && (t.setProperty("num", this.toMml(!1)), this.Clear()), t.isKind("cell") && this.isOpen) {
+			if (t.getProperty("linebreak")) return e.fail;
+			throw new y("Misplaced", "Misplaced %1", t.getName());
+		}
+		if (t.isClose && this.getErrors(t.kind)) {
+			let [e, n] = this.getErrors(t.kind);
+			throw new y(e, n, t.getName());
+		}
+		return t.isFinal ? (this.Push(t.First), e.fail) : e.success;
+	}
+	clearEnv() {
+		for (let e of Object.keys(this.env)) delete this.env[e];
+	}
+	setProperties(e) {
+		return Object.assign(this._properties, e), this;
+	}
+	getName() {
+		return this.getProperty("name");
+	}
+	toString() {
+		return this.kind + "[" + this.nodes.join("; ") + "]";
+	}
+	getErrors(t) {
+		return this.constructor.errors[t] || e.errors[t];
+	}
+	addLatexItem(e, t = "") {
+		let n = this.startStr.slice(this.startI, this.stopI);
+		if (n) {
+			let r = t ? t + n : n;
+			e.attributes.set(m.Attr.LATEXITEM, r), r !== "}" && e.attributes.set(m.Attr.LATEX, r);
+		}
+	}
+};
+b.fail = [null, !1], b.success = [null, !0], b.errors = {
+	end: ["MissingBeginExtraEnd", "Missing \\begin{%1} or extra \\end{%1}"],
+	close: ["ExtraCloseMissingOpen", "Extra close brace or missing open brace"],
+	right: ["MissingLeftExtraRight", "Missing \\left or extra \\right"],
+	middle: ["ExtraMiddle", "Extra \\middle"]
+};
+//#endregion
+//#region node_modules/@mathjax/src/mjs/input/tex/TexParser.js
+var x = class e {
+	constructor(e, t, n) {
+		this._string = e, this.configuration = n, this.macroCount = 0, this.i = 0, this.currentCS = "", this.saveI = 0;
+		let r = Object.hasOwn(t, "isInner"), i = t.isInner;
+		delete t.isInner;
+		let a;
+		if (t) {
+			a = {};
+			for (let e of Object.keys(t)) a[e] = t[e];
+		}
+		this.configuration.pushParser(this), this.stack = new re(this.itemFactory, a, r ? i : !0), this.Parse(), this.Push(this.itemFactory.create("stop")), this.stack.env = a;
+	}
+	get options() {
+		return this.configuration.options;
+	}
+	get itemFactory() {
+		return this.configuration.itemFactory;
+	}
+	get tags() {
+		return this.configuration.tags;
+	}
+	set string(e) {
+		this._string = e;
+	}
+	get string() {
+		return this._string;
+	}
+	parse(e, t) {
+		let n = this.saveI;
+		this.saveI = this.i - +(e === "character" && t[1] !== "&");
+		let r = this.configuration.handlers.get(e).parse(t);
+		return e !== "macro" && this.updateResult(t[1], n), this.saveI = n, r;
+	}
+	lookup(e, t) {
+		return this.configuration.handlers.get(e).lookup(t);
+	}
+	contains(e, t) {
+		return this.configuration.handlers.get(e).contains(t);
+	}
+	toString() {
+		let e = "";
+		for (let t of Array.from(this.configuration.handlers.keys())) e += t + ": " + this.configuration.handlers.get(t) + "\n";
+		return e;
+	}
+	Parse() {
+		let e;
+		for (; this.i < this.string.length;) e = this.getCodePoint(), this.i += e.length, this.parse(g.CHARACTER, [this, e]);
+	}
+	Push(e) {
+		e instanceof b && (e.startI = this.saveI, e.stopI = this.i, e.startStr = this.string), e instanceof l && e.isInferred ? this.PushAll(e.childNodes) : this.stack.Push(e);
+	}
+	PushAll(e) {
+		for (let t of e) this.stack.Push(t);
+	}
+	mml() {
+		if (!this.stack.Top().isKind("mml")) return null;
+		let e = this.stack.Top().First;
+		this.configuration.popParser();
+		let t = this.trimTex(this.string);
+		return t && e.attributes.set(m.Attr.LATEX, t), e;
+	}
+	convertDelimiter(e) {
+		return this.lookup(g.DELIMITER, e)?.char ?? null;
+	}
+	getCodePoint() {
+		let e = this.string.codePointAt(this.i);
+		return e === void 0 ? "" : String.fromCodePoint(e);
+	}
+	nextIsSpace() {
+		return !!this.string.charAt(this.i).match(/\s/);
+	}
+	GetNext() {
+		for (; this.nextIsSpace();) this.i++;
+		return this.getCodePoint();
+	}
+	GetCS() {
+		let e = this.string.slice(this.i).match(/^(([a-z]+) ?|[\uD800-\uDBFF].|.)/i);
+		return e ? (this.i += e[0].length, e[2] || e[1]) : (this.i++, " ");
+	}
+	GetArgument(e, t = !1) {
+		switch (this.GetNext()) {
+			case "":
+				if (!t) throw new y("MissingArgFor", "Missing argument for %1", this.currentCS);
+				return null;
+			case "}":
+				if (!t) throw new y("ExtraCloseMissingOpen", "Extra close brace or missing open brace");
+				return null;
+			case "\\": return this.i++, "\\" + this.GetCS();
+			case "{": {
+				let e = ++this.i, t = 1;
+				for (; this.i < this.string.length;) switch (this.string.charAt(this.i++)) {
+					case "\\":
+						this.i++;
+						break;
+					case "{":
+						t++;
+						break;
+					case "}":
+						if (--t === 0) return this.string.slice(e, this.i - 1);
+						break;
+				}
+				throw new y("MissingCloseBrace", "Missing close brace");
+			}
+		}
+		let n = this.getCodePoint();
+		return this.i += n.length, n;
+	}
+	GetBrackets(e, t, n = !1) {
+		if (this.GetNext() !== "[") return t;
+		let r = ++this.i, i = 0, a = 0;
+		for (; this.i < this.string.length;) switch (this.string.charAt(this.i++)) {
+			case "{":
+				i++;
+				break;
+			case "\\":
+				this.i++;
+				break;
+			case "}":
+				if (i-- <= 0) throw new y("ExtraCloseLooking", "Extra close brace while looking for %1", "']'");
+				break;
+			case "[":
+				i === 0 && a++;
+				break;
+			case "]":
+				if (i === 0) {
+					if (!n || a === 0) return this.string.slice(r, this.i - 1);
+					a--;
+				}
+				break;
+		}
+		throw new y("MissingCloseBracket", "Could not find closing ']' for argument to %1", this.currentCS);
+	}
+	GetDelimiter(e, t = !1) {
+		let n = this.GetNext();
+		if (this.i += n.length, this.i <= this.string.length && (n === "\\" ? n += this.GetCS() : n === "{" && t && (this.i--, n = this.GetArgument(e).trim()), this.contains(g.DELIMITER, n))) return this.convertDelimiter(n);
+		throw new y("MissingOrUnrecognizedDelim", "Missing or unrecognized delimiter for %1", this.currentCS);
+	}
+	GetDimen(e) {
+		if (this.GetNext() === "{") {
+			let t = this.GetArgument(e), [n, r] = v.matchDimen(t);
+			if (n) return n + r;
+		} else {
+			let e = this.string.slice(this.i), [t, n, r] = v.matchDimen(e, !0);
+			if (t) return this.i += r, t + n;
+		}
+		throw new y("MissingDimOrUnits", "Missing dimension or its units for %1", this.currentCS);
+	}
+	GetUpTo(e, t) {
+		for (; this.nextIsSpace();) this.i++;
+		let n = this.i, r = 0;
+		for (; this.i < this.string.length;) {
+			let e = this.i, i = this.GetNext();
+			switch (this.i += i.length, i) {
+				case "\\":
+					i += this.GetCS();
+					break;
+				case "{":
+					r++;
+					break;
+				case "}":
+					if (r === 0) throw new y("ExtraCloseLooking", "Extra close brace while looking for %1", t);
+					r--;
+					break;
+			}
+			if (r === 0 && i === t) return this.string.slice(n, e);
+		}
+		throw new y("TokenNotFoundForCommand", "Could not find %1 for %2", t, this.currentCS);
+	}
+	ParseArg(t) {
+		return new e(this.GetArgument(t), this.stack.env, this.configuration).mml();
+	}
+	ParseUpTo(t, n) {
+		return new e(this.GetUpTo(t, n), this.stack.env, this.configuration).mml();
+	}
+	GetDelimiterArg(e) {
+		let t = v.trimSpaces(this.GetArgument(e));
+		if (t === "") return null;
+		if (this.contains(g.DELIMITER, t)) return t;
+		throw new y("MissingOrUnrecognizedDelim", "Missing or unrecognized delimiter for %1", this.currentCS);
+	}
+	GetStar() {
+		let e = this.GetNext() === "*";
+		return e && this.i++, e;
+	}
+	create(e, ...t) {
+		let n = this.configuration.nodeFactory.create(e, ...t);
+		return n.isToken && n.attributes.hasExplicit("mathvariant") && n.attributes.get("mathvariant").charAt(0) === "-" && n.setProperty("ignore-variant", !0), n;
+	}
+	trimTex(e) {
+		return e.trim() + (e.match(/(?:^|[^\\])(?:\\\\)*\\\s+$/) ? " " : "");
+	}
+	updateResult(e, t) {
+		let n = this.stack.Prev(!0);
+		if (!n) return;
+		let r = m.Attr.LATEX, i = n.attributes.get(r), a = n.attributes.get(m.Attr.LATEXITEM);
+		if (a !== void 0) {
+			i || (e === "}" || a === "}" ? this.composeBraces(n) : n.attributes.set(r, a));
+			return;
+		}
+		t = t < this.saveI ? this.saveI : t;
+		let o = this.trimTex(t === this.i ? e : this.string.slice(t, this.i));
+		if (!(!o || o === i || e === "\\" && o === "\\")) {
+			if (o === "_" || o === "^") n.setProperty("sub-sup", o);
+			else {
+				switch (n.getProperty("sub-sup")) {
+					case "^":
+						if (n.childNodes[2] && (o === "}" ? this.composeBraces(n.childNodes[2]) : n.childNodes[2].attributes.hasExplicit(r) || n.childNodes[2].attributes.set(r, o)), n.childNodes[1]) {
+							let e = n.childNodes[1].attributes.get(r);
+							this.composeLatex(n, `_${e}^`, 0, 2);
+						} else this.composeLatex(n, "^", 0, 2);
+						return;
+					case "_":
+						if (n.childNodes[1] && (o === "}" ? this.composeBraces(n.childNodes[1]) : n.childNodes[1].attributes.hasExplicit(r) || n.childNodes[1].attributes.set(r, o)), n.childNodes[2]) {
+							let e = n.childNodes[2].attributes.get(r);
+							this.composeLatex(n, `^${e}_`, 0, 1);
+						} else this.composeLatex(n, "_", 0, 1);
+						return;
+				}
+				if (o === "}") {
+					this.composeBraces(n);
+					return;
+				}
+			}
+			n.attributes.set(r, o);
+		}
+	}
+	composeLatex(e, t, n, r) {
+		if (!e.childNodes[n] || !e.childNodes[r]) return;
+		let i = m.Attr.LATEX, a = (e.childNodes[n].attributes.get(i) || "") + t + e.childNodes[r].attributes.get(i);
+		e.attributes.set(i, a);
+	}
+	composeBraces(e) {
+		let t = this.composeBracedContent(e);
+		e.attributes.set(m.Attr.LATEX, `{${t}}`);
+	}
+	composeBracedContent(e) {
+		let t = e.childNodes[0]?.childNodes || [], n = "";
+		for (let e of t) {
+			let t = (e?.attributes)?.get(m.Attr.LATEX) || "";
+			t && (n += n && n.match(/[a-zA-Z]$/) && t.match(/^[a-zA-Z]/) ? " " + t : t);
+		}
+		return n;
+	}
+}, S = class {
+	static oneof(...e) {
+		return new this("string", (t) => e.includes(t), (e) => e);
+	}
+	constructor(e, t, n) {
+		this.name = e, this.verify = t, this.convert = n;
+	}
+};
+new S("boolean", (e) => e === "true" || e === "false", (e) => e === "true"), new S("number", (e) => !!e.match(/^[-+]?(?:\d+(?:\.\d*)?|\.\d+)(?:e[-+]?\d+)?$/), (e) => parseFloat(e)), new S("integer", (e) => !!e.match(/^[-+]?\d+$/), (e) => parseInt(e)), new S("string", (e) => !0, (e) => e), new S("dimen", (e) => v.matchDimen(e)[0] !== null, (e) => e);
+function ae(e, t = !1) {
+	let n = {}, r = e, i, a, o, s = !0;
+	for (; r;) [a, i, r] = w(r, ["=", ","], t, s), s = !1, i === "=" ? ([o, i, r] = w(r, [","], t), o = o === "false" || o === "true" ? JSON.parse(o) : o, n[a] = o) : a && (n[a] = !0);
+	return n;
+}
+function C(e, t) {
+	if (t === 0) return e.replace(/^\s+/, "").replace(/([^\\\s]|^)((?:\\\\)*(?:\\\s)?)?\s+$/, "$1$2");
+	for (; t > 0;) e = e.trim().slice(1, -1), t--;
+	return e;
+}
+function w(e, t, n = !1, r = !1) {
+	let i = e.length, a = 0, o = "", s = 0, c = 0, l = !0;
+	for (; s < i;) {
+		let r = e[s++];
+		switch (r) {
+			case "\\":
+				o += r + (e[s++] || ""), l = !1;
+				continue;
+			case " ": break;
+			case "{":
+				l && c++, a++;
+				break;
+			case "}":
+				if (!a) throw new y("ExtraCloseMissingOpen", "Extra close brace or missing open brace");
+				a--, l = !1;
+				break;
+			default:
+				if (!a && t.includes(r)) return [
+					C(o, n ? Math.min(1, c) : c),
+					r,
+					e.slice(s)
+				];
+				c > a && (c = a), l = !1;
+		}
+		o += r;
+	}
+	if (a) throw new y("ExtraOpenMissingClose", "Extra open brace or missing close brace");
+	return r && c ? [
+		"",
+		"",
+		C(o, 1)
+	] : [
+		C(o, n ? Math.min(1, c) : c),
+		"",
+		e.slice(s)
+	];
+}
+var T = {
+	cols(...e) {
+		return e.map((e) => v.em(e)).join(" ");
+	},
+	fenced(e, t, n, r, i = "", a = "") {
+		let o = e.nodeFactory, c = o.create("node", "mrow", [], {
+			open: t,
+			close: r,
+			texClass: s.INNER
+		}), l;
+		if (i) l = new x("\\" + i + "l" + t, e.parser.stack.env, e).mml();
+		else {
+			let e = o.create("text", t);
+			l = o.create("node", "mo", [], {
+				fence: !0,
+				stretchy: !0,
+				symmetric: !0,
+				texClass: s.OPEN
+			}, e);
+		}
+		if (p.appendChildren(c, [l, n]), i) l = new x("\\" + i + "r" + r, e.parser.stack.env, e).mml();
+		else {
+			let e = o.create("text", r);
+			l = o.create("node", "mo", [], {
+				fence: !0,
+				stretchy: !0,
+				symmetric: !0,
+				texClass: s.CLOSE
+			}, e);
+		}
+		return a && l.attributes.set("mathcolor", a), p.appendChildren(c, [l]), c;
+	},
+	fixedFence(e, t, n, r) {
+		let i = e.nodeFactory.create("node", "mrow", [], {
+			open: t,
+			close: r,
+			texClass: s.ORD
+		});
+		return t && p.appendChildren(i, [T.mathPalette(e, t, "l")]), p.isType(n, "mrow") ? p.appendChildren(i, p.getChildren(n)) : p.appendChildren(i, [n]), r && p.appendChildren(i, [T.mathPalette(e, r, "r")]), i;
+	},
+	mathPalette(e, t, n) {
+		(t === "{" || t === "}") && (t = "\\" + t);
+		let r = "{\\bigg" + n + " " + t + "}", i = "{\\big" + n + " " + t + "}";
+		return new x("\\mathchoice" + r + i + i + i, {}, e).mml();
+	},
+	fixInitialMO(e, t) {
+		for (let n = 0, r = t.length; n < r; n++) {
+			let r = t[n];
+			if (r && !p.isType(r, "mspace") && (!p.isType(r, "TeXAtom") || p.getChildren(r)[0] && p.getChildren(p.getChildren(r)[0]).length)) {
+				if (p.isEmbellished(r) || p.isType(r, "TeXAtom") && p.getTexClass(r) === s.REL) {
+					let n = e.nodeFactory.create("node", "mi");
+					t.unshift(n);
+				}
+				break;
+			}
+		}
+	},
+	internalMath(e, t, n, r) {
+		if (t = t.replace(/ +/g, " "), e.configuration.options.internalMath) return e.configuration.options.internalMath(e, t, n, r);
+		let i = r || e.stack.env.font, a = i ? { mathvariant: i } : {}, o = [], s = 0, c = 0, l, u, d = "", f = 0;
+		if (t.match(/\\?[${}\\]|\\\(|\\(?:eq)?ref\s*\{|\\U/)) {
+			for (; s < t.length;) if (l = t.charAt(s++), l === "$") d === "$" && f === 0 ? (u = e.create("node", "TeXAtom", [new x(t.slice(c, s - 1), {}, e.configuration).mml()]), o.push(u), d = "", c = s) : d === "" && (c < s - 1 && o.push(T.internalText(e, t.slice(c, s - 1), a)), d = "$", c = s);
+			else if (l === "{" && d !== "") f++;
+			else if (l === "}") if (d === "}" && f === 0) {
+				let n = new x(t.slice(c, s), {}, e.configuration).mml();
+				u = e.create("node", "TeXAtom", [n], a), o.push(u), d = "", c = s;
+			} else d !== "" && f && f--;
+			else if (l === "\\") {
+				if (d === "" && t.substring(s).match(/^(eq)?ref\s*\{/)) {
+					let n = RegExp["$&"].length;
+					c < s - 1 && o.push(T.internalText(e, t.slice(c, s - 1), a)), d = "}", c = s - 1, s += n;
+				} else if (l = t.charAt(s++), l === "(" && d === "") c < s - 2 && o.push(T.internalText(e, t.slice(c, s - 2), a)), d = ")", c = s;
+				else if (l === ")" && d === ")" && f === 0) u = e.create("node", "TeXAtom", [new x(t.slice(c, s - 2), {}, e.configuration).mml()]), o.push(u), d = "", c = s;
+				else if (l.match(/[${}\\]/) && d === "") s--, t = t.substring(0, s - 1) + t.substring(s);
+				else if (l === "U") {
+					let e = t.substring(s).match(/^\s*(?:([0-9A-F])|\{\s*([0-9A-F]+)\s*\})/);
+					if (!e) throw new y("BadRawUnicode", "Argument to %1 must a hexadecimal number with 1 to 6 digits", "\\U");
+					let n = String.fromCodePoint(parseInt(e[1] || e[2], 16));
+					t = t.substring(0, s - 2) + n + t.substring(s + e[0].length), s = s - 2 + n.length;
+				}
+			}
+			if (d !== "") throw new y("MathNotTerminated", "Math mode is not properly terminated");
+		}
+		return c < t.length && o.push(T.internalText(e, t.slice(c), a)), n == null ? o.length > 1 && (o = [e.create("node", "mrow", o)]) : o = [e.create("node", "mstyle", o, {
+			displaystyle: !1,
+			scriptlevel: n
+		})], o;
+	},
+	internalText(e, t, n) {
+		t = t.replace(/\n+/g, " ").replace(/^ +/, a.nbsp).replace(/ +$/, a.nbsp);
+		let r = e.create("text", t);
+		return e.create("node", "mtext", [], n, r);
+	},
+	underOver(e, t, n, r, i) {
+		if (T.checkMovableLimits(t), p.isType(t, "munderover") && p.isEmbellished(t)) {
+			p.setProperties(p.getCoreMO(t), {
+				lspace: 0,
+				rspace: 0
+			});
+			let n = e.create("node", "mo", [], { rspace: 0 });
+			t = e.create("node", "mrow", [n, t]);
+		}
+		let a = e.create("node", "munderover", [t]);
+		p.setChild(a, r === "over" ? a.over : a.under, n);
+		let o = a;
+		return i && (o = e.create("node", "TeXAtom", [e.create("node", "mstyle", [a], {
+			displaystyle: !0,
+			scriptlevel: 0
+		})], {
+			texClass: s.OP,
+			movesupsub: !0
+		})), p.setProperty(o, "subsupOK", !0), o;
+	},
+	checkMovableLimits(e) {
+		let t = p.isType(e, "mo") ? p.getForm(e) : null;
+		(p.getProperty(e, "movablelimits") || t && t[3] && t[3].movablelimits) && p.setProperties(e, { movablelimits: !1 });
+	},
+	setArrayAlign(e, t, n) {
+		return n || (t = v.trimSpaces(t || "")), t === "t" ? e.arraydef.align = "baseline 1" : t === "b" ? e.arraydef.align = "baseline -1" : t === "c" ? e.arraydef.align = "axis" : t && (n ? (n.string = `[${t}]` + n.string.slice(n.i), n.i = 0) : e.arraydef.align = t), e;
+	},
+	substituteArgs(e, t, n) {
+		let r = "", i = "", a = 0;
+		for (; a < n.length;) {
+			let o = n.charAt(a++);
+			if (o === "\\") r += o + n.charAt(a++);
+			else if (o === "#") if (o = n.charAt(a++), o === "#") r += o;
+			else {
+				if (!o.match(/[1-9]/) || parseInt(o, 10) > t.length) throw new y("IllegalMacroParam", "Illegal macro parameter reference");
+				i = T.addArgs(e, T.addArgs(e, i, r), t[parseInt(o, 10) - 1]), r = "";
+			}
+			else r += o;
+		}
+		return T.addArgs(e, i, r);
+	},
+	addArgs(e, t, n) {
+		if (n.match(/^[a-z]/i) && t.match(/(^|[^\\])(\\\\)*\\[a-z]+$/i) && (t += " "), t.length + n.length > e.configuration.options.maxBuffer) throw new y("MaxBufferSize", "MathJax internal buffer size exceeded; is there a recursive macro call?");
+		return t + n;
+	},
+	checkMaxMacros(e, t = !0) {
+		if (!(++e.macroCount <= e.configuration.options.maxMacros)) throw t ? new y("MaxMacroSub1", "MathJax maximum macro substitution count exceeded; is here a recursive macro call?") : new y("MaxMacroSub2", "MathJax maximum substitution count exceeded; is there a recursive latex environment?");
+	},
+	checkEqnEnv(e, t = !0) {
+		let n = e.stack.Top(), r = n.First;
+		if (!(n.getProperty("nestable") && t && !r || n.getProperty("nestStart")) && (!n.isKind("start") || r)) throw new y("ErroneousNestingEq", "Erroneous nesting of equation structures");
+	},
+	copyNode(e, t) {
+		let n = e.copy(), r = t.configuration;
+		return n.walkTree((e) => {
+			r.addNode(e.kind, e);
+			let t = (e.getProperty("in-lists") || "").split(/,/);
+			for (let n of t) n && r.addNode(n, e);
+		}), n;
+	},
+	mmlFilterAttribute(e, t, n) {
+		return n;
+	},
+	getFontDef(e) {
+		let t = e.stack.env.font;
+		return t ? { mathvariant: t } : {};
+	},
+	keyvalOptions(e, t = null, n = !1, r = !1) {
+		let i = ae(e, r);
+		if (t) for (let e of Object.keys(i)) if (Object.hasOwn(t, e)) {
+			if (t[e] instanceof S) {
+				let n = t[e], r = String(i[e]);
+				if (!n.verify(r)) throw new y("InvalidValue", "Value for key '%1' is not of the expected type", e);
+				i[e] = n.convert(r);
+			}
+		} else {
+			if (n) throw new y("InvalidOption", "Invalid option: %1", e);
+			delete i[e];
+		}
+		return i;
+	},
+	isLatinOrGreekChar(e) {
+		return !!e.normalize("NFD").match(/[a-zA-Z\u0370-\u03F0]/);
+	}
+}, E = class {
+	constructor(e = "???", t = "") {
+		this.tag = e, this.id = t;
+	}
+}, D = class {
+	constructor(e = "", t = !1, n = !1, r = null, i = "", a = "", o = !1, s = "") {
+		this.env = e, this.taggable = t, this.defaultTags = n, this.tag = r, this.tagId = i, this.tagFormat = a, this.noTag = o, this.labelId = s;
+	}
+}, O = class {
+	constructor() {
+		this.counter = 0, this.allCounter = 0, this.configuration = null, this.ids = {}, this.allIds = {}, this.labels = {}, this.allLabels = {}, this.redo = !1, this.refUpdate = !1, this.currentTag = new D(), this.history = [], this.stack = [], this.enTag = function(e, t) {
+			let n = this.configuration.nodeFactory, r = n.create("node", "mtd", [e]), i = n.create("node", "mlabeledtr", [t, r]);
+			return n.create("node", "mtable", [i], {
+				side: this.configuration.options.tagSide,
+				minlabelspacing: this.configuration.options.tagIndent,
+				displaystyle: !0
+			});
+		};
+	}
+	start(e, t, n) {
+		this.currentTag && this.stack.push(this.currentTag);
+		let r = this.label;
+		this.currentTag = new D(e, t, n), this.label = r;
+	}
+	get env() {
+		return this.currentTag.env;
+	}
+	end() {
+		this.history.push(this.currentTag);
+		let e = this.label;
+		this.currentTag = this.stack.pop(), e && !this.label && (this.label = e);
+	}
+	tag(e, t) {
+		this.currentTag.tag = e, this.currentTag.tagFormat = t ? e : this.formatTag(e), this.currentTag.noTag = !1;
+	}
+	notag() {
+		this.tag("", !0), this.currentTag.noTag = !0;
+	}
+	get noTag() {
+		return this.currentTag.noTag;
+	}
+	set label(e) {
+		this.currentTag.labelId = e;
+	}
+	get label() {
+		return this.currentTag.labelId;
+	}
+	formatUrl(e, t) {
+		return t + "#" + encodeURIComponent(e);
+	}
+	formatTag(e) {
+		return [
+			"(",
+			e,
+			")"
+		];
+	}
+	formatRef(e) {
+		return this.formatTag(e);
+	}
+	formatId(e) {
+		return "mjx-eqn:" + e.replace(/\s/g, "_");
+	}
+	formatNumber(e) {
+		return e.toString();
+	}
+	autoTag() {
+		this.currentTag.tag ?? (this.counter++, this.tag(this.formatNumber(this.counter), !1));
+	}
+	clearTag() {
+		this.tag(null, !0), this.currentTag.tagId = "";
+	}
+	getTag(e = !1) {
+		if (e) return this.autoTag(), this.makeTag();
+		let t = this.currentTag;
+		return t.taggable && !t.noTag && (t.defaultTags && this.autoTag(), t.tag) ? this.makeTag() : null;
+	}
+	resetTag() {
+		this.history = [], this.redo = !1, this.refUpdate = !1, this.clearTag();
+	}
+	reset(e = 0) {
+		this.resetTag(), this.counter = this.allCounter = e, this.allLabels = {}, this.allIds = {}, this.label = "";
+	}
+	startEquation(e) {
+		this.history = [], this.stack = [], this.clearTag(), this.currentTag = new D("", void 0, void 0), this.labels = {}, this.ids = {}, this.counter = this.allCounter, this.redo = !1;
+		let t = e.inputData.recompile;
+		t && (this.refUpdate = !0, this.counter = t.counter);
+	}
+	finishEquation(e) {
+		this.redo && (e.inputData.recompile = {
+			state: e.state(),
+			counter: this.allCounter
+		}), this.refUpdate || (this.allCounter = this.counter), Object.assign(this.allIds, this.ids), Object.assign(this.allLabels, this.labels);
+	}
+	finalize(e, t) {
+		if (!t.display || this.currentTag.env || this.currentTag.tag == null) return e;
+		let n = this.makeTag();
+		return this.enTag(e, n);
+	}
+	makeId() {
+		this.currentTag.tagId = this.formatId(this.configuration.options.useLabelIds && this.label || this.currentTag.tag);
+	}
+	makeTag() {
+		this.makeId(), this.label &&= (this.labels[this.label] = new E(this.currentTag.tag, this.currentTag.tagId), "");
+		let e = this.currentTag.tagFormat, t = new x((Array.isArray(e) ? e : e.match(/^(\(|\[|\{)(.*)(\}|\]|\))$/)?.slice(1) || [e]).map((e) => e ? `\\text{${e}}` : "").join(""), {}, this.configuration).mml();
+		return this.configuration.nodeFactory.create("node", "mtd", [t], {
+			id: this.currentTag.tagId,
+			rowalign: this.configuration.options.tagAlign
+		});
+	}
+}, k = new Map([["none", class extends O {
+	autoTag() {}
+	getTag() {
+		return this.currentTag.tag ? super.getTag() : null;
+	}
+}], ["all", class extends O {
+	finalize(e, t) {
+		if (!t.display || this.history.find(function(e) {
+			return e.taggable;
+		})) return e;
+		let n = this.getTag(!0);
+		return this.enTag(e, n);
+	}
+}]]), A = "none", j = {
+	OPTIONS: {
+		tags: A,
+		tagSide: "right",
+		tagIndent: "0.8em",
+		useLabelIds: !0,
+		ignoreDuplicateLabels: !1,
+		tagAlign: "baseline"
+	},
+	add(e, t) {
+		k.set(e, t);
+	},
+	addTags(e) {
+		for (let t of Object.keys(e)) j.add(t, e[t]);
+	},
+	create(e) {
+		let t = k.get(e) || k.get(A);
+		if (!t) throw Error("Unknown tags class");
+		return new t();
+	},
+	setDefault(e) {
+		A = e;
+	},
+	getDefault() {
+		return j.create(A);
+	}
+}, M = class {
+	constructor(e, t, n) {
+		this._token = e, this._char = t, this._attributes = n;
+	}
+	get token() {
+		return this._token;
+	}
+	get char() {
+		return this._char;
+	}
+	get attributes() {
+		return this._attributes;
+	}
+}, N = class {
+	constructor(e, t, n = []) {
+		this._token = e, this._func = t, this._args = n;
+	}
+	get token() {
+		return this._token;
+	}
+	get func() {
+		return this._func;
+	}
+	get args() {
+		return this._args;
+	}
+};
+//#endregion
+//#region node_modules/@mathjax/src/mjs/input/tex/TokenMap.js
+function P(e) {
+	return e === void 0 ? !0 : e;
+}
+var F = class {
+	constructor(e, t) {
+		this._name = e, this._parser = t, B.register(this);
+	}
+	get name() {
+		return this._name;
+	}
+	parserFor(e) {
+		return this.contains(e) ? this.parser : null;
+	}
+	parse([e, t]) {
+		let n = this.parserFor(t), r = this.lookup(t);
+		return n && r ? P(n(e, r)) : null;
+	}
+	set parser(e) {
+		this._parser = e;
+	}
+	get parser() {
+		return this._parser;
+	}
+}, oe = class extends F {
+	constructor(e, t, n) {
+		super(e, t), this._regExp = n;
+	}
+	contains(e) {
+		return this._regExp.test(e);
+	}
+	lookup(e) {
+		return this.contains(e) ? e : null;
+	}
+}, I = class extends F {
+	constructor() {
+		super(...arguments), this.map = /* @__PURE__ */ new Map();
+	}
+	lookup(e) {
+		return this.map.get(e);
+	}
+	contains(e) {
+		return this.map.has(e);
+	}
+	add(e, t) {
+		this.map.set(e, t);
+	}
+	remove(e) {
+		this.map.delete(e);
+	}
+}, L = class extends I {
+	constructor(e, t, n) {
+		super(e, t);
+		for (let e of Object.keys(n)) {
+			let t = n[e], [r, i] = typeof t == "string" ? [t, null] : t, a = new M(e, r, i);
+			this.add(e, a);
+		}
+	}
+}, se = class extends L {
+	parse([e, t]) {
+		return super.parse([e, "\\" + t]);
+	}
+}, R = class extends I {
+	constructor(e, t, n = {}) {
+		super(e, null);
+		let r = (e) => typeof e == "string" ? n[e] : e;
+		for (let [e, n] of Object.entries(t)) {
+			let t, i;
+			Array.isArray(n) ? (t = r(n[0]), i = n.slice(1)) : (t = r(n), i = []);
+			let a = new N(e, t, i);
+			this.add(e, a);
+		}
+	}
+	parserFor(e) {
+		let t = this.lookup(e);
+		return t ? t.func : null;
+	}
+	parse([e, t]) {
+		let n = this.lookup(t), r = this.parserFor(t);
+		return !n || !r ? null : P(r(e, n.token, ...n.args));
+	}
+}, ce = class extends R {
+	parse([e, t]) {
+		let n = this.lookup(t), r = this.parserFor(t);
+		if (!n || !r) return null;
+		let i = e.currentCS;
+		e.currentCS = "\\" + t;
+		let a = r(e, "\\" + n.token, ...n.args);
+		return e.currentCS = i, P(a);
+	}
+}, le = class extends R {
+	constructor(e, t, n, r = {}) {
+		super(e, n, r), this.parser = t;
+	}
+	parse([e, t]) {
+		let n = this.lookup(t), r = this.parserFor(t);
+		return !n || !r ? null : P(this.parser(e, n.token, r, n.args));
+	}
+}, z = /* @__PURE__ */ new Map(), B = {
+	register(e) {
+		z.set(e.name, e);
+	},
+	getMap(e) {
+		return z.get(e);
+	}
+}, V = class e {
+	constructor() {
+		this._configuration = new r(), this._fallback = new d();
+	}
+	add(e, t, n = r.DEFAULTPRIORITY) {
+		for (let t of e.slice().reverse()) {
+			let e = B.getMap(t);
+			if (!e) {
+				this.warn(`Configuration '${t}' not found! Omitted.`);
+				return;
+			}
+			this._configuration.add(e, n);
+		}
+		t && this._fallback.add(t, n);
+	}
+	remove(e, t = null) {
+		for (let t of e) {
+			let e = this.retrieve(t);
+			e && this._configuration.remove(e);
+		}
+		t && this._fallback.remove(t);
+	}
+	parse(t) {
+		for (let { item: n } of this._configuration) {
+			let r = n.parse(t);
+			if (r === e.FALLBACK) break;
+			if (r) return r;
+		}
+		let [n, r] = t;
+		Array.from(this._fallback)[0].item(n, r);
+	}
+	lookup(e) {
+		let t = this.applicable(e);
+		return t ? t.lookup(e) : null;
+	}
+	contains(e) {
+		let t = this.applicable(e);
+		return !!t && !(t instanceof L && t.lookup(e).char === null);
+	}
+	toString() {
+		let e = [];
+		for (let { item: t } of this._configuration) e.push(t.name);
+		return e.join(", ");
+	}
+	applicable(e) {
+		for (let { item: t } of this._configuration) if (t.contains(e)) return t;
+		return null;
+	}
+	retrieve(e) {
+		for (let { item: t } of this._configuration) if (t.name === e) return t;
+		return null;
+	}
+	warn(e) {
+		console.log("TexParser Warning: " + e);
+	}
+};
+V.FALLBACK = Symbol("fallback");
+var ue = class {
+	constructor() {
+		this.map = /* @__PURE__ */ new Map();
+	}
+	add(e, t, n = r.DEFAULTPRIORITY) {
+		for (let r of Object.keys(e)) {
+			let i = r, a = this.get(i);
+			a || (a = new V(), this.set(i, a)), a.add(e[i], t[i], n);
+		}
+	}
+	remove(e, t) {
+		for (let n of Object.keys(e)) {
+			let r = this.get(n);
+			r && r.remove(e[n], t[n]);
+		}
+	}
+	set(e, t) {
+		this.map.set(e, t);
+	}
+	get(e) {
+		return this.map.get(e);
+	}
+	retrieve(e) {
+		for (let t of this.map.values()) {
+			let n = t.retrieve(e);
+			if (n) return n;
+		}
+		return null;
+	}
+	keys() {
+		return this.map.keys();
+	}
+}, de = class e {
+	static makeProcessor(e, t) {
+		return Array.isArray(e) ? e : [e, t];
+	}
+	static _create(t, n = {}) {
+		let i = n.priority ?? r.DEFAULTPRIORITY, a = n.init ? this.makeProcessor(n.init, i) : null, o = n.config ? this.makeProcessor(n.config, i) : null, s = (n.preprocessors || []).map((e) => this.makeProcessor(e, i)), c = (n.postprocessors || []).map((e) => this.makeProcessor(e, i)), l = n.parser || "tex";
+		return new e(t, n[h.HANDLER] || {}, n[h.FALLBACK] || {}, n[h.ITEMS] || {}, n[h.TAGS] || {}, n[h.OPTIONS] || {}, n[h.NODES] || {}, s, c, a, o, i, l);
+	}
+	static create(t, n = {}) {
+		let r = e._create(t, n);
+		return U.set(t, r), r;
+	}
+	static local(t = {}) {
+		return e._create("", t);
+	}
+	constructor(e, t = {}, n = {}, r = {}, i = {}, a = {}, o = {}, s = [], c = [], l = null, u = null, d, f) {
+		this.name = e, this.handler = t, this.fallback = n, this.items = r, this.tags = i, this.options = a, this.nodes = o, this.preprocessors = s, this.postprocessors = c, this.initMethod = l, this.configMethod = u, this.priority = d, this.parser = f, this.handler = Object.assign({
+			[g.CHARACTER]: [],
+			[g.DELIMITER]: [],
+			[g.MACRO]: [],
+			[g.ENVIRONMENT]: []
+		}, t);
+	}
+	get init() {
+		return this.initMethod ? this.initMethod[0] : null;
+	}
+	get config() {
+		return this.configMethod ? this.configMethod[0] : null;
+	}
+}, H = /* @__PURE__ */ new Map(), U = {
+	set(e, t) {
+		H.set(e, t);
+	},
+	get(e) {
+		return H.get(e);
+	},
+	keys() {
+		return H.keys();
+	}
+}, fe = class {
+	constructor(e, t = ["tex"]) {
+		this.initMethod = new d(), this.configMethod = new d(), this.configurations = new r(), this.parsers = [], this.handlers = new ue(), this.items = {}, this.tags = {}, this.options = {}, this.nodes = {}, this.parsers = t;
+		for (let t of e.slice().reverse()) this.addPackage(t);
+		for (let { item: e, priority: t } of this.configurations) this.append(e, t);
+	}
+	init() {
+		this.initMethod.execute(this);
+	}
+	config(e) {
+		this.configMethod.execute(this, e);
+		for (let t of this.configurations) this.addFilters(e, t.item);
+	}
+	addPackage(e) {
+		let t = typeof e == "string" ? e : e[0], n = this.getPackage(t);
+		n && this.configurations.add(n, typeof e == "string" ? n.priority : e[1]);
+	}
+	add(t, r, i = {}) {
+		let a = this.getPackage(t);
+		this.append(a), this.configurations.add(a, a.priority), this.init();
+		let o = r.parseOptions;
+		o.nodeFactory.setCreators(a.nodes);
+		for (let e of Object.keys(a.items)) o.itemFactory.setNodeClass(e, a.items[e]);
+		j.addTags(a.tags), n(o.options, a.options), e(o.options, i), this.addFilters(r, a), a.config && a.config(this, r);
+	}
+	getPackage(e) {
+		let t = U.get(e);
+		if (t && !this.parsers.includes(t.parser)) throw Error(`Package '${e}' doesn't target the proper parser`);
+		return t || this.warn(`Package '${e}' not found.  Omitted.`), t;
+	}
+	append(e, t) {
+		t ||= e.priority, e.initMethod && this.initMethod.add(e.initMethod[0], e.initMethod[1]), e.configMethod && this.configMethod.add(e.configMethod[0], e.configMethod[1]), this.handlers.add(e.handler, e.fallback, t), Object.assign(this.items, e.items), Object.assign(this.tags, e.tags), n(this.options, e.options), Object.assign(this.nodes, e.nodes);
+	}
+	addFilters(e, t) {
+		for (let [n, r] of t.preprocessors) e.preFilters.add(n, r);
+		for (let [n, r] of t.postprocessors) e.postFilters.add(n, r);
+	}
+	warn(e) {
+		console.warn("MathJax Warning: " + e);
+	}
+}, pe = class extends b {
+	constructor(e, t) {
+		super(e), this.global = t;
+	}
+	get kind() {
+		return "start";
+	}
+	get isOpen() {
+		return !0;
+	}
+	checkItem(e) {
+		if (e.isKind("stop")) {
+			let e = this.toMml();
+			return this.global.isInner || (e = this.factory.configuration.tags.finalize(e, this.env)), [[this.factory.create("mml", e)], !0];
+		}
+		return super.checkItem(e);
+	}
+}, me = class extends b {
+	get kind() {
+		return "stop";
+	}
+	get isClose() {
+		return !0;
+	}
+}, W = class extends b {
+	get kind() {
+		return "open";
+	}
+	get isOpen() {
+		return !0;
+	}
+	checkItem(e) {
+		if (e.isKind("close")) {
+			let t = this.toMml(), n = this.create("node", "TeXAtom", [t]);
+			return e.addLatexItem(n), [[this.factory.create("mml", n)], !0];
+		}
+		return super.checkItem(e);
+	}
+};
+W.errors = Object.assign(Object.create(b.errors), { stop: ["ExtraOpenMissingClose", "Extra open brace or missing close brace"] });
+var he = class extends b {
+	get kind() {
+		return "close";
+	}
+	get isClose() {
+		return !0;
+	}
+}, ge = class extends b {
+	get kind() {
+		return "null";
+	}
+}, _e = class extends b {
+	get kind() {
+		return "prime";
+	}
+	checkItem(e) {
+		let [t, n] = this.Peek(2), r = (p.isType(t, "msubsup") || p.isType(t, "msup")) && !p.getChildAt(t, t.sup), i = (p.isType(t, "munderover") || p.isType(t, "mover")) && !p.getChildAt(t, t.over) && !p.getProperty(t, "subsupOK");
+		if (!r && !i) return [[this.create("node", t.getProperty("movesupsub") ? "mover" : "msup", [t, n]), e], !0];
+		let a = r ? t.sup : t.over;
+		return p.setChild(t, a, n), [[t, e], !0];
+	}
+}, G = class extends b {
+	get kind() {
+		return "subsup";
+	}
+	checkItem(e) {
+		if (e.isKind("open") || e.isKind("left")) return b.success;
+		let t = this.First, n = this.getProperty("position");
+		if (e.isKind("mml")) return this.getProperty("primes") && (n === 2 ? (p.setProperty(this.getProperty("primes"), "variantForm", !0), e.First = this.create("node", "mrow", [this.getProperty("primes"), e.First])) : p.setChild(t, 2, this.getProperty("primes"))), p.setChild(t, n, e.First), this.getProperty("movesupsub") != null && p.setProperty(t, "movesupsub", this.getProperty("movesupsub")), [[this.factory.create("mml", t)], !0];
+		super.checkItem(e);
+		let r = this.getErrors([
+			"",
+			"sub",
+			"sup"
+		][n]);
+		throw new y(r[0], r[1], ...r.splice(2));
+	}
+};
+G.errors = Object.assign(Object.create(b.errors), {
+	stop: ["MissingScript", "Missing superscript or subscript argument"],
+	sup: ["MissingOpenForSup", "Missing open brace for superscript"],
+	sub: ["MissingOpenForSub", "Missing open brace for subscript"]
+});
+var ve = class extends b {
+	constructor(e) {
+		super(e), this.setProperty("name", "\\over");
+	}
+	get kind() {
+		return "over";
+	}
+	get isClose() {
+		return !0;
+	}
+	checkItem(e) {
+		if (e.isKind("over")) throw new y("AmbiguousUseOf", "Ambiguous use of %1", e.getName());
+		if (e.isClose) {
+			let t = this.create("node", "mfrac", [this.getProperty("num"), this.toMml(!1)]);
+			return this.getProperty("thickness") != null && p.setAttribute(t, "linethickness", this.getProperty("thickness")), (this.getProperty("ldelim") || this.getProperty("rdelim")) && (p.setProperty(t, "withDelims", !0), t = T.fixedFence(this.factory.configuration, this.getProperty("ldelim"), t, this.getProperty("rdelim"))), t.attributes.set(m.Attr.LATEXITEM, this.getProperty("name")), [[this.factory.create("mml", t), e], !0];
+		}
+		return super.checkItem(e);
+	}
+	toString() {
+		return "over[" + this.getProperty("num") + " / " + this.nodes.join("; ") + "]";
+	}
+}, K = class extends b {
+	constructor(e, t) {
+		super(e), this.setProperty("delim", t);
+	}
+	get kind() {
+		return "left";
+	}
+	get isOpen() {
+		return !0;
+	}
+	checkItem(e) {
+		if (e.isKind("right")) {
+			let t = T.fenced(this.factory.configuration, this.getProperty("delim"), this.toMml(), e.getProperty("delim"), "", e.getProperty("color")), n = t.childNodes[0], r = t.childNodes[t.childNodes.length - 1], i = this.factory.create("mml", t);
+			return this.addLatexItem(n, "\\left"), e.addLatexItem(r, "\\right"), i.Peek()[0].attributes.set(m.Attr.LATEXITEM, "\\left" + e.startStr.slice(this.startI, e.stopI)), [[i], !0];
+		}
+		if (e.isKind("middle")) {
+			let t = { stretchy: !0 };
+			e.getProperty("color") && (t.mathcolor = e.getProperty("color"));
+			let n = this.create("token", "mo", t, e.getProperty("delim"));
+			return e.addLatexItem(n, "\\middle"), this.Push(this.create("node", "TeXAtom", [], { texClass: s.CLOSE }), n, this.create("node", "TeXAtom", [], { texClass: s.OPEN })), this.env = {}, [[this], !0];
+		}
+		return super.checkItem(e);
+	}
+};
+K.errors = Object.assign(Object.create(b.errors), { stop: ["ExtraLeftMissingRight", "Extra \\left or missing \\right"] });
+var ye = class extends b {
+	constructor(e, t, n) {
+		super(e), this.setProperty("delim", t), n && this.setProperty("color", n);
+	}
+	get kind() {
+		return "middle";
+	}
+	get isClose() {
+		return !0;
+	}
+}, be = class extends b {
+	constructor(e, t, n) {
+		super(e), this.setProperty("delim", t), n && this.setProperty("color", n);
+	}
+	get kind() {
+		return "right";
+	}
+	get isClose() {
+		return !0;
+	}
+}, xe = class extends b {
+	get kind() {
+		return "break";
+	}
+	constructor(e, t, n) {
+		super(e), this.setProperty("linebreak", t), this.setProperty("insert", n);
+	}
+	checkItem(e) {
+		let t = this.getProperty("linebreak");
+		if (e.isKind("mml")) {
+			let n = e.First;
+			if (n.isKind("mo")) {
+				if ((p.getOp(n)?.[3]?.linebreakstyle || p.getAttribute(n, "linebreakstyle")) !== "after") return p.setAttribute(n, "linebreak", t), [[e], !0];
+				if (!this.getProperty("insert")) return [[e], !0];
+			}
+		}
+		let n = this.create("token", "mspace", { linebreak: t });
+		return [[this.factory.create("mml", n), e], !0];
+	}
+}, q = class extends b {
+	get kind() {
+		return "begin";
+	}
+	get isOpen() {
+		return !0;
+	}
+	checkItem(e) {
+		if (e.isKind("end")) {
+			if (e.getName() !== this.getName()) throw new y("EnvBadEnd", "\\begin{%1} ended with \\end{%2}", this.getName(), e.getName());
+			let t = this.toMml();
+			return e.addLatexItem(t), [[this.factory.create("mml", t)], !0];
+		}
+		if (e.isKind("stop")) throw new y("EnvMissingEnd", "Missing \\end{%1}", this.getName());
+		return super.checkItem(e);
+	}
+}, Se = class extends b {
+	get kind() {
+		return "end";
+	}
+	get isClose() {
+		return !0;
+	}
+}, Ce = class extends b {
+	get kind() {
+		return "style";
+	}
+	checkItem(e) {
+		if (!e.isClose) return super.checkItem(e);
+		let t = this.create("node", "mstyle", this.nodes, this.getProperty("styles"));
+		return [[this.factory.create("mml", t), e], !0];
+	}
+}, we = class extends b {
+	get kind() {
+		return "position";
+	}
+	checkItem(e) {
+		if (e.isClose) throw new y("MissingBoxFor", "Missing box for %1", this.getName());
+		if (e.isFinal) {
+			let t = e.toMml();
+			switch (this.getProperty("move")) {
+				case "vertical": return t = this.create("node", "mpadded", [t], {
+					height: this.getProperty("dh"),
+					depth: this.getProperty("dd"),
+					voffset: this.getProperty("dh")
+				}), [[this.factory.create("mml", t)], !0];
+				case "horizontal": return [[
+					this.factory.create("mml", this.getProperty("left")),
+					e,
+					this.factory.create("mml", this.getProperty("right"))
+				], !0];
+			}
+		}
+		return super.checkItem(e);
+	}
+}, Te = class extends b {
+	get kind() {
+		return "cell";
+	}
+	get isClose() {
+		return !0;
+	}
+}, Ee = class extends b {
+	get isFinal() {
+		return !0;
+	}
+	get kind() {
+		return "mml";
+	}
+}, De = class extends b {
+	get kind() {
+		return "fn";
+	}
+	checkItem(e) {
+		let t = this.First;
+		if (t) {
+			if (e.isOpen) return b.success;
+			if (!e.isKind("fn")) {
+				let n = e.First;
+				if (!e.isKind("mml") || !n || p.isType(n, "mstyle") && n.childNodes.length && p.isType(n.childNodes[0].childNodes[0], "mspace") || p.isType(n, "mspace")) return [[t, e], !0];
+				p.isEmbellished(n) && (n = p.getCoreMO(n));
+				let r = p.getForm(n);
+				if (r != null && [
+					0,
+					0,
+					1,
+					1,
+					0,
+					1,
+					1,
+					0,
+					0,
+					0
+				][r[2]]) return [[t, e], !0];
+			}
+			return t.isKind("TeXAtom") && t.isEmpty ? [[t, e], !0] : [[
+				t,
+				this.create("token", "mo", { texClass: s.NONE }, a.ApplyFunction),
+				e
+			], !0];
+		}
+		return super.checkItem(e);
+	}
+}, Oe = class extends b {
+	constructor() {
+		super(...arguments), this.remap = B.getMap("not_remap");
+	}
+	get kind() {
+		return "not";
+	}
+	checkItem(e) {
+		let t, n, r;
+		if (e.isKind("open") || e.isKind("left")) return b.success;
+		if (e.isKind("mml") && (p.isType(e.First, "mo") || p.isType(e.First, "mi") || p.isType(e.First, "mtext")) && (t = e.First, n = p.getText(t), n.length === 1 && !p.getProperty(t, "movesupsub") && p.getChildren(t).length === 1)) return this.remap.contains(n) ? (r = this.create("text", this.remap.lookup(n).char), p.setChild(t, 0, r)) : (r = this.create("text", "̸"), p.appendChildren(t, [r])), [[e], !0];
+		r = this.create("text", "⧸");
+		let i = this.create("node", "mtext", [], {}, r), a = this.create("node", "mpadded", [i], { width: 0 });
+		return t = this.create("node", "TeXAtom", [a], { texClass: s.REL }), [[t, e], !0];
+	}
+}, ke = class extends b {
+	get kind() {
+		return "nonscript";
+	}
+	checkItem(e) {
+		if (e.isKind("mml") && e.Size() === 1) {
+			let t = e.First;
+			if (t.isKind("mstyle") && t.notParent && (t = p.getChildren(p.getChildren(t)[0])[0]), t.isKind("mspace")) {
+				if (t !== e.First) {
+					let t = this.create("node", "mrow", [e.Pop()]);
+					e.Push(t);
+				}
+				this.factory.configuration.addNode("nonscript", e.First);
+			}
+		}
+		return [[e], !0];
+	}
+}, Ae = class extends b {
+	get kind() {
+		return "dots";
+	}
+	checkItem(e) {
+		if (e.isKind("open") || e.isKind("left")) return b.success;
+		let t = this.getProperty("ldots"), n = e.First;
+		if (e.isKind("mml") && p.isEmbellished(n)) {
+			let e = p.getTexClass(p.getCoreMO(n));
+			(e === s.BIN || e === s.REL) && (t = this.getProperty("cdots"));
+		}
+		return [[t, e], !0];
+	}
+}, J = class extends b {
+	constructor() {
+		super(...arguments), this.table = [], this.row = [], this.frame = [], this.hfill = [], this.arraydef = {}, this.cstart = [], this.cend = [], this.cextra = [], this.atEnd = !1, this.ralign = [], this.breakAlign = {
+			cell: "",
+			row: "",
+			table: ""
+		}, this.templateSubs = 0;
+	}
+	get kind() {
+		return "array";
+	}
+	get isOpen() {
+		return !0;
+	}
+	get copyEnv() {
+		return !1;
+	}
+	checkItem(e) {
+		if (e.isClose && !e.isKind("over")) {
+			if (e.getProperty("isEntry")) return this.EndEntry(), this.clearEnv(), this.StartEntry(), b.fail;
+			if (e.getProperty("isCR")) return this.EndEntry(), this.EndRow(), this.clearEnv(), this.StartEntry(), b.fail;
+			this.EndTable(), this.clearEnv();
+			let t = this.factory.create("mml", this.createMml());
+			if (this.getProperty("requireClose")) {
+				if (e.isKind("close")) return [[t], !0];
+				throw new y("MissingCloseBrace", "Missing close brace");
+			}
+			return [[t, e], !0];
+		}
+		return super.checkItem(e);
+	}
+	createMml() {
+		let e = this.arraydef.scriptlevel;
+		delete this.arraydef.scriptlevel;
+		let t = this.create("node", "mtable", this.table, this.arraydef);
+		return e && t.setProperty("smallmatrix", !0), this.breakAlign.table && p.setAttribute(t, "data-break-align", this.breakAlign.table), this.getProperty("arrayPadding") && (p.setAttribute(t, "data-frame-styles", ""), p.setAttribute(t, "framespacing", this.getProperty("arrayPadding"))), t = this.handleFrame(t), e !== void 0 && (t = this.create("node", "mstyle", [t], { scriptlevel: e })), (this.getProperty("open") || this.getProperty("close")) && (t = T.fenced(this.factory.configuration, this.getProperty("open"), t, this.getProperty("close"))), t;
+	}
+	handleFrame(e) {
+		if (!this.frame.length) return e;
+		let t = new Map(this.frame), n = this.frame.reduce((e, [, t]) => t === e ? t : "", this.frame[0][1]);
+		if (n) {
+			if (this.frame.length === 4) return p.setAttribute(e, "frame", n), p.removeAttribute(e, "data-frame-styles"), e;
+			if (n === "solid") return p.setAttribute(e, "data-frame-styles", ""), e = this.create("node", "menclose", [e], {
+				notation: Array.from(t.keys()).join(" "),
+				"data-padding": 0
+			}), e;
+		}
+		let r = i.map((e) => t.get(e) || "none").join(" ");
+		return p.setAttribute(e, "data-frame-styles", r), e;
+	}
+	StartEntry() {
+		let e = this.row.length, t = this.cstart[e], n = this.cend[e], r = this.ralign[e], i = this.cextra;
+		if (!t && !n && !r && !i[e] && !i[e + 1]) return;
+		let [a, o, s, c] = this.getEntry();
+		if (i[e] && (!this.atEnd || i[e + 1]) && (t += "&"), s !== "&" && (c = !!o.trim() || !!(e || s && s.substring(0, 4) !== "\\end"), i[e + 1] && !i[e] && (n = (n || "") + "&", this.atEnd = !0)), !c && !a) return;
+		let l = this.parser;
+		if (c && (t && (o = T.addArgs(l, t, o)), n && (o = T.addArgs(l, o, n)), r && (o = "\\text{" + o.trim() + "}"), (t || n || r) && ++this.templateSubs > l.configuration.options.maxTemplateSubtitutions)) throw new y("MaxTemplateSubs", "Maximum template substitutions exceeded; is there an invalid use of \\\\ in the template?");
+		a && (o = T.addArgs(l, a, o)), l.string = T.addArgs(l, o, l.string), l.i = 0;
+	}
+	getEntry() {
+		let e = this.parser, t = /^([^]*?)([&{}]|\\\\|\\(?:begin|end)\s*\{array\}|\\cr|\\)/, n = 0, r = 0, i = e.i, a, o = [
+			"",
+			"",
+			"",
+			!1
+		];
+		for (; (a = e.string.slice(i).match(t)) !== null;) switch (i += a[0].length, a[2]) {
+			case "\\":
+				i++;
+				break;
+			case "{":
+				n++;
+				break;
+			case "}":
+				if (!n) return o;
+				n--;
+				break;
+			case "\\begin{array}":
+				n || r++;
+				break;
+			case "\\end{array}": if (!n && r) {
+				r--;
+				break;
+			}
+			default: {
+				if (n || r) continue;
+				i -= a[2].length;
+				let t = e.string.slice(e.i, i).trim(), o = t.match(/^(?:\s*\\(?:h(?:dash)?line|hfil{1,3}|rowcolor\s*\{.*?\}))+/);
+				return o && (t = t.slice(o[0].length)), e.string = e.string.slice(i), e.i = 0, [
+					o?.[0] || "",
+					t,
+					a[2],
+					!0
+				];
+			}
+		}
+		return o;
+	}
+	EndEntry() {
+		let e = this.create("node", "mtd", this.nodes);
+		this.hfill.length && (this.hfill[0] === 0 && p.setAttribute(e, "columnalign", "right"), this.hfill[this.hfill.length - 1] === this.Size() && p.setAttribute(e, "columnalign", p.getAttribute(e, "columnalign") ? "center" : "left"));
+		let t = this.ralign[this.row.length];
+		if (t) {
+			let [n, r, i] = t, a = this.create("node", "mpadded", e.childNodes[0].childNodes, {
+				width: r,
+				"data-overflow": "auto",
+				"data-align": i,
+				"data-vertical-align": n
+			});
+			a.setProperty("vbox", n), e.childNodes[0].childNodes = [], e.appendChild(a);
+		} else this.breakAlign.cell && p.setAttribute(e, "data-vertical-align", this.breakAlign.cell);
+		this.breakAlign.cell = "", this.row.push(e), this.Clear(), this.hfill = [];
+	}
+	EndRow() {
+		let e = "mtr";
+		this.getProperty("isNumbered") && this.row.length === 3 ? (this.row.unshift(this.row.pop()), e = "mlabeledtr") : this.getProperty("isLabeled") && (e = "mlabeledtr", this.setProperty("isLabeled", !1));
+		let t = this.create("node", e, this.row);
+		this.breakAlign.row && (p.setAttribute(t, "data-break-align", this.breakAlign.row), this.breakAlign.row = ""), this.addLatexItem(t), this.table.push(t), this.row = [], this.atEnd = !1;
+	}
+	EndTable() {
+		(this.Size() || this.row.length) && (this.EndEntry(), this.EndRow()), this.checkLines();
+	}
+	checkLines() {
+		if (this.arraydef.rowlines) {
+			let e = this.arraydef.rowlines.split(/ /);
+			e.length === this.table.length ? (this.frame.push(["bottom", e.pop()]), e.length ? this.arraydef.rowlines = e.join(" ") : delete this.arraydef.rowlines) : e.length < this.table.length - 1 && (this.arraydef.rowlines += " none");
+		}
+		if (this.getProperty("rowspacing")) {
+			let e = this.arraydef.rowspacing.split(/ /);
+			for (; e.length < this.table.length;) e.push(this.getProperty("rowspacing") + "em");
+			this.arraydef.rowspacing = e.join(" ");
+		}
+	}
+	addRowSpacing(e) {
+		if (this.arraydef.rowspacing) {
+			let t = this.arraydef.rowspacing.split(/ /);
+			if (!this.getProperty("rowspacing")) {
+				let e = v.dimen2em(t[0]);
+				this.setProperty("rowspacing", e);
+			}
+			let n = this.getProperty("rowspacing");
+			for (; t.length < this.table.length;) t.push(v.em(n));
+			t[this.table.length - 1] = v.em(Math.max(0, n + v.dimen2em(e))), this.arraydef.rowspacing = t.join(" ");
+		}
+	}
+}, je = class extends J {
+	constructor(e, ...t) {
+		super(e), this.maxrow = 0, this.factory.configuration.tags.start(t[0], t[2], t[1]);
+	}
+	get kind() {
+		return "eqnarray";
+	}
+	EndEntry() {
+		let e = this.arraydef.columnalign.split(/ /);
+		(this.row.length && e.length ? e[this.row.length % e.length] : "right") !== "right" && T.fixInitialMO(this.factory.configuration, this.nodes), super.EndEntry();
+	}
+	EndRow() {
+		this.row.length > this.maxrow && (this.maxrow = this.row.length);
+		let e = this.factory.configuration.tags.getTag();
+		e && (this.row = [e].concat(this.row), this.setProperty("isLabeled", !0)), this.factory.configuration.tags.clearTag(), super.EndRow();
+	}
+	EndTable() {
+		super.EndTable(), this.factory.configuration.tags.end(), this.extendArray("columnalign", this.maxrow), this.extendArray("columnwidth", this.maxrow), this.extendArray("columnspacing", this.maxrow - 1), this.extendArray("data-break-align", this.maxrow), this.addIndentshift();
+	}
+	extendArray(e, t) {
+		if (!this.arraydef[e]) return;
+		let n = this.arraydef[e].split(/ /), r = [...n];
+		if (r.length > 1) {
+			for (; r.length < t;) r.push(...n);
+			this.arraydef[e] = r.slice(0, t).join(" ");
+		}
+	}
+	addIndentshift() {
+		let e = this.arraydef.columnalign.split(/ /), t = "";
+		for (let n of e.keys()) {
+			if (e[n] === "left" && n > 0) {
+				let e = t === "center" ? ".7em" : "2em";
+				for (let t of this.table) {
+					let r = t.childNodes[t.isKind("mlabeledtr") ? n + 1 : n];
+					if (r) {
+						let t = this.create("node", "mstyle", r.childNodes[0].childNodes, { indentshift: e });
+						r.childNodes[0].childNodes = [], r.appendChild(t);
+					}
+				}
+			}
+			t = e[n];
+		}
+	}
+}, Y = class extends q {
+	get kind() {
+		return "mstyle";
+	}
+	constructor(e, t, n) {
+		super(e), this.attrList = t, this.setProperty("name", n);
+	}
+	checkItem(e) {
+		return e.isKind("end") && e.getName() === this.getName() ? [[this.create("node", "mstyle", [this.toMml()], this.attrList)], !0] : super.checkItem(e);
+	}
+}, Me = class extends b {
+	constructor(e, ...t) {
+		super(e), this.factory.configuration.tags.start("equation", !0, t[0]);
+	}
+	get kind() {
+		return "equation";
+	}
+	get isOpen() {
+		return !0;
+	}
+	checkItem(e) {
+		if (e.isKind("end")) {
+			let t = this.toMml(), n = this.factory.configuration.tags.getTag();
+			return this.factory.configuration.tags.end(), [[n ? this.factory.configuration.tags.enTag(t, n) : t, e], !0];
+		}
+		if (e.isKind("stop")) throw new y("EnvMissingEnd", "Missing \\end{%1}", this.getName());
+		return super.checkItem(e);
+	}
+}, Ne = 1.2 / .85, Pe = {
+	fontfamily: 1,
+	fontsize: 1,
+	fontweight: 1,
+	fontstyle: 1,
+	color: 1,
+	background: 1,
+	id: 1,
+	class: 1,
+	href: 1,
+	style: 1
+};
+function X(e, t = Infinity) {
+	let n = e.replace(/\s+/g, "").split("").map((e) => {
+		let t = {
+			t: "top",
+			b: "bottom",
+			m: "middle",
+			c: "center"
+		}[e];
+		if (!t) throw new y("BadBreakAlign", "Invalid alignment character: %1", e);
+		return t;
+	});
+	if (n.length > t) throw new y("TooManyAligns", "Too many alignment characters: %1", e);
+	return t === 1 ? n[0] : n.join(" ");
+}
+function Z(e, t) {
+	let n = e.stack.env, r = n.inRoot;
+	n.inRoot = !0;
+	let i = new x(t, n, e.configuration), a = i.mml(), o = i.stack.global;
+	if (o.leftRoot || o.upRoot) {
+		let t = {};
+		o.leftRoot && (t.width = o.leftRoot), o.upRoot && (t.voffset = o.upRoot, t.height = o.upRoot), a = e.create("node", "mpadded", [a], t);
+	}
+	return n.inRoot = r, a;
+}
+var Q = {
+	Open(e, t) {
+		e.Push(e.itemFactory.create("open"));
+	},
+	Close(e, t) {
+		e.Push(e.itemFactory.create("close"));
+	},
+	Bar(e, t) {
+		let n = e.create("token", "mo", {
+			stretchy: !1,
+			texClass: s.ORD
+		}, t);
+		n.setProperty("keep-attrs", "stretchy"), e.Push(n);
+	},
+	Tilde(e, t) {
+		e.Push(e.create("token", "mtext", {}, a.nbsp));
+	},
+	Space(e, t) {},
+	Superscript(e, t) {
+		e.GetNext().match(/\d/) && (e.string = e.string.substring(0, e.i + 1) + " " + e.string.substring(e.i + 1));
+		let n, r, i = e.stack.Top();
+		i.isKind("prime") ? ([r, n] = i.Peek(2), e.stack.Pop()) : (r = e.stack.Prev(), r ||= e.create("token", "mi", {}, ""));
+		let a = p.getProperty(r, "movesupsub"), o = p.isType(r, "msubsup") ? r.sup : r.over;
+		if (p.isType(r, "msubsup") && !p.isType(r, "msup") && p.getChildAt(r, r.sup) || p.isType(r, "munderover") && !p.isType(r, "mover") && p.getChildAt(r, r.over) && !p.getProperty(r, "subsupOK")) throw new y("DoubleExponent", "Double exponent: use braces to clarify");
+		(!p.isType(r, "msubsup") || p.isType(r, "msup")) && (a ? ((!p.isType(r, "munderover") || p.isType(r, "mover") || p.getChildAt(r, r.over)) && (r = e.create("node", "munderover", [r], { movesupsub: !0 })), o = r.over) : (r = e.create("node", "msubsup", [r]), o = r.sup)), e.Push(e.itemFactory.create("subsup", r).setProperties({
+			position: o,
+			primes: n,
+			movesupsub: a
+		}));
+	},
+	Subscript(e, t) {
+		e.GetNext().match(/\d/) && (e.string = e.string.substring(0, e.i + 1) + " " + e.string.substring(e.i + 1));
+		let n, r, i = e.stack.Top();
+		i.isKind("prime") ? ([r, n] = i.Peek(2), e.stack.Pop()) : (r = e.stack.Prev(), r ||= e.create("token", "mi", {}, ""));
+		let a = p.getProperty(r, "movesupsub"), o = p.isType(r, "msubsup") ? r.sub : r.under;
+		if (p.isType(r, "msubsup") && !p.isType(r, "msup") && p.getChildAt(r, r.sub) || p.isType(r, "munderover") && !p.isType(r, "mover") && p.getChildAt(r, r.under) && !p.getProperty(r, "subsupOK")) throw new y("DoubleSubscripts", "Double subscripts: use braces to clarify");
+		(!p.isType(r, "msubsup") || p.isType(r, "msup")) && (a ? ((!p.isType(r, "munderover") || p.isType(r, "mover") || p.getChildAt(r, r.under)) && (r = e.create("node", "munderover", [r], { movesupsub: !0 })), o = r.under) : (r = e.create("node", "msubsup", [r]), o = r.sub)), e.Push(e.itemFactory.create("subsup", r).setProperties({
+			position: o,
+			primes: n,
+			movesupsub: a
+		}));
+	},
+	Prime(e, t) {
+		let n = e.stack.Prev();
+		if (n ||= e.create("token", "mi"), p.isType(n, "msubsup") && !p.isType(n, "msup") && p.getChildAt(n, n.sup) || p.isType(n, "munderover") && !p.isType(n, "mover") && p.getChildAt(n, n.over) && !p.getProperty(n, "subsupOK")) throw new y("DoubleExponentPrime", "Prime causes double exponent: use braces to clarify");
+		let r = "";
+		e.i--;
+		do
+			r += a.prime, e.i++, t = e.GetNext();
+		while (t === "'" || t === a.rsquo);
+		r = [
+			"",
+			"′",
+			"″",
+			"‴",
+			"⁗"
+		][r.length] || r;
+		let i = e.create("token", "mo", { variantForm: !0 }, r);
+		e.Push(e.itemFactory.create("prime", n, i));
+	},
+	Comment(e, t) {
+		for (; e.i < e.string.length && e.string.charAt(e.i) !== "\n";) e.i++;
+	},
+	Hash(e, t) {
+		throw new y("CantUseHash1", "You can't use 'macro parameter character #' in math mode");
+	},
+	MathFont(e, t, n, r = "") {
+		let i = new x(e.GetArgument(t), Object.assign(Object.assign({ multiLetterIdentifiers: e.options.identifierPattern }, e.stack.env), {
+			font: n,
+			italicFont: r,
+			noAutoOP: !0
+		}), e.configuration).mml();
+		e.Push(e.create("node", "TeXAtom", [i]));
+	},
+	SetFont(e, t, n) {
+		e.stack.env.font = n, e.Push(e.itemFactory.create("null"));
+	},
+	SetStyle(e, t, n, r, i) {
+		e.stack.env.style = n, e.stack.env.level = i, e.Push(e.itemFactory.create("style").setProperty("styles", {
+			displaystyle: r,
+			scriptlevel: i
+		}));
+	},
+	SetSize(e, t, n) {
+		e.stack.env.size = n, e.Push(e.itemFactory.create("style").setProperty("styles", { mathsize: f(n) }));
+	},
+	Spacer(e, t, n) {
+		let r = e.create("node", "mspace", [], { width: f(n) }), i = e.create("node", "mstyle", [r], { scriptlevel: 0 });
+		e.Push(i);
+	},
+	DiscretionaryTimes(e, t) {
+		e.Push(e.create("token", "mo", { linebreakmultchar: "×" }, "⁢"));
+	},
+	AllowBreak(e, t) {
+		e.Push(e.create("token", "mspace"));
+	},
+	Break(e, t) {
+		e.Push(e.create("token", "mspace", { linebreak: m.LineBreak.NEWLINE }));
+	},
+	Linebreak(e, t, n) {
+		let r = !0, i = e.stack.Prev(!0);
+		i && i.isKind("mo") && p.getMoAttribute(i, "linebreakstyle") !== m.LineBreakStyle.BEFORE && (i.attributes.set("linebreak", n), r = !1), e.Push(e.itemFactory.create("break", n, r));
+	},
+	LeftRight(e, t) {
+		let n = t.substring(1);
+		e.Push(e.itemFactory.create(n, e.GetDelimiter(t), e.stack.env.color));
+	},
+	NamedFn(e, t, n) {
+		n ||= t.substring(1);
+		let r = e.create("token", "mi", { texClass: s.OP }, n);
+		e.Push(e.itemFactory.create("fn", r));
+	},
+	NamedOp(e, t, n) {
+		n ||= t.substring(1), n = n.replace(/&thinsp;/, " ");
+		let r = e.create("token", "mo", {
+			movablelimits: !0,
+			movesupsub: !0,
+			form: m.Form.PREFIX,
+			texClass: s.OP
+		}, n);
+		e.Push(r);
+	},
+	Limits(e, t, n) {
+		let r = e.stack.Prev(!0);
+		if (!r || p.getTexClass(p.getCoreMO(r)) !== s.OP && p.getProperty(r, "movesupsub") == null) throw new y("MisplacedLimits", "%1 is allowed only on operators", e.currentCS);
+		let i = e.stack.Top(), a;
+		p.isType(r, "munderover") && !n ? (a = e.create("node", "msubsup"), p.copyChildren(r, a), r = i.Last = a) : p.isType(r, "msubsup") && n && (a = e.create("node", "munderover"), p.copyChildren(r, a), r = i.Last = a), p.setProperty(r, "movesupsub", !!n), p.setProperties(p.getCoreMO(r), { movablelimits: !1 }), ((p.isType(r, "mo") ? p.getMoAttribute(r, "movableLimits") : p.getAttribute(r, "movablelimits")) || p.getProperty(r, "movablelimits")) && p.setProperties(r, { movablelimits: !1 });
+	},
+	Over(e, t, n, r) {
+		let i = e.itemFactory.create("over").setProperty("name", e.currentCS);
+		n || r ? (i.setProperty("ldelim", n), i.setProperty("rdelim", r)) : t.match(/withdelims$/) && (i.setProperty("ldelim", e.GetDelimiter(t)), i.setProperty("rdelim", e.GetDelimiter(t))), t.match(/^\\above/) ? i.setProperty("thickness", e.GetDimen(t)) : (t.match(/^\\atop/) || n || r) && i.setProperty("thickness", 0), e.Push(i);
+	},
+	Frac(e, t) {
+		let n = e.ParseArg(t), r = e.ParseArg(t), i = e.create("node", "mfrac", [n, r]);
+		e.Push(i);
+	},
+	Sqrt(e, t) {
+		let n = e.GetBrackets(t), r = e.GetArgument(t);
+		r === "\\frac" && (r += "{" + e.GetArgument(r) + "}{" + e.GetArgument(r) + "}");
+		let i = new x(r, e.stack.env, e.configuration).mml();
+		i = n ? e.create("node", "mroot", [i, Z(e, n)]) : e.create("node", "msqrt", [i]), e.Push(i);
+	},
+	Root(e, t) {
+		let n = e.GetUpTo(t, "\\of"), r = e.ParseArg(t), i = e.create("node", "mroot", [r, Z(e, n)]);
+		e.Push(i);
+	},
+	MoveRoot(e, t, n) {
+		if (!e.stack.env.inRoot) throw new y("MisplacedMoveRoot", "%1 can appear only within a root", e.currentCS);
+		if (e.stack.global[n]) throw new y("MultipleMoveRoot", "Multiple use of %1", e.currentCS);
+		let r = e.GetArgument(t);
+		if (!r.match(/-?[0-9]+/)) throw new y("IntegerArg", "The argument to %1 must be an integer", e.currentCS);
+		r = parseInt(r, 10) / 15 + "em", r.substring(0, 1) !== "-" && (r = "+" + r), e.stack.global[n] = r;
+	},
+	Accent(e, t, n, r) {
+		let i = e.ParseArg(t), a = Object.assign(Object.assign({}, T.getFontDef(e)), {
+			accent: !0,
+			mathaccent: r === void 0 ? !0 : r
+		}), o = p.createEntity(n), s = e.create("token", "mo", a, o);
+		p.setAttribute(s, "stretchy", !!r);
+		let c = p.isEmbellished(i) ? p.getCoreMO(i) : i;
+		(p.isType(c, "mo") || p.getProperty(c, "movablelimits")) && p.setProperties(c, { movablelimits: !1 });
+		let l = e.create("node", "munderover");
+		p.setChild(l, 0, i), p.setChild(l, 1, null), p.setChild(l, 2, s);
+		let u = e.create("node", "TeXAtom", [l]);
+		e.Push(u);
+	},
+	UnderOver(e, t, n, r) {
+		let i = p.createEntity(n), a = e.create("token", "mo", {
+			stretchy: !0,
+			accent: !0
+		}, i);
+		i.match(u.mathaccentsWithWidth) && a.setProperty("mathaccent", !1);
+		let o = t.charAt(1) === "o" ? "over" : "under", s = e.ParseArg(t);
+		e.Push(T.underOver(e, s, a, o, r));
+	},
+	Overset(e, t) {
+		let n = e.ParseArg(t), r = e.ParseArg(t), i = n.coreMO(), a = i.isKind("mo") && p.getMoAttribute(i, "accent") === !0;
+		T.checkMovableLimits(r);
+		let o = e.create("node", "mover", [r, n], { accent: a });
+		e.Push(o);
+	},
+	Underset(e, t) {
+		let n = e.ParseArg(t), r = e.ParseArg(t), i = n.coreMO(), a = i.isKind("mo") && p.getMoAttribute(i, "accent") === !0;
+		T.checkMovableLimits(r);
+		let o = e.create("node", "munder", [r, n], { accentunder: a });
+		e.Push(o);
+	},
+	Overunderset(e, t) {
+		let n = e.ParseArg(t), r = e.ParseArg(t), i = e.ParseArg(t), a = n.coreMO(), o = r.coreMO(), s = a.isKind("mo") && p.getMoAttribute(a, "accent") === !0, c = o.isKind("mo") && p.getMoAttribute(o, "accent") === !0;
+		T.checkMovableLimits(i);
+		let l = e.create("node", "munderover", [
+			i,
+			r,
+			n
+		], {
+			accent: s,
+			accentunder: c
+		});
+		e.Push(l);
+	},
+	TeXAtom(e, t, n) {
+		let r = { texClass: n }, i, a;
+		if (n === s.OP) {
+			r.movesupsub = r.movablelimits = !0;
+			let n = e.GetArgument(t), o = n.match(/^\s*\\rm\s+([a-zA-Z0-9 ]+)$/);
+			if (o) r.mathvariant = m.Variant.NORMAL, a = e.create("token", "mi", r, o[1]);
+			else {
+				let t = new x(n, e.stack.env, e.configuration).mml();
+				a = e.create("node", "TeXAtom", [t], r);
+			}
+			i = e.itemFactory.create("fn", a);
+		} else i = e.create("node", "TeXAtom", [e.ParseArg(t)], r);
+		e.Push(i);
+	},
+	VBox(e, t, n) {
+		let r = new x(e.GetArgument(t), e.stack.env, e.configuration), i = {
+			"data-vertical-align": n,
+			texClass: s.ORD
+		};
+		r.stack.env.hsize && (i.width = r.stack.env.hsize, i["data-overflow"] = "linebreak");
+		let a = e.create("node", "mpadded", [r.mml()], i);
+		a.setProperty("vbox", n), e.Push(a);
+	},
+	Hsize(e, t) {
+		e.GetNext() === "=" && e.i++, e.stack.env.hsize = e.GetDimen(t), e.Push(e.itemFactory.create("null"));
+	},
+	ParBox(e, t) {
+		let n = e.GetBrackets(t, "c"), r = e.GetDimen(t), i = T.internalMath(e, e.GetArgument(t)), a = X(n, 1), o = e.create("node", "mpadded", i, {
+			width: r,
+			"data-overflow": "linebreak",
+			"data-vertical-align": a
+		});
+		o.setProperty("vbox", a), e.Push(o);
+	},
+	BreakAlign(e, t) {
+		let n = e.stack.Top();
+		if (!(n instanceof J)) throw new y("BreakNotInArray", "%1 must be used in an alignment environment", e.currentCS);
+		switch (e.GetArgument(t).trim()) {
+			case "c":
+				if (n.First) throw new y("BreakFirstInEntry", "%1 must be at the beginning of an alignment entry", e.currentCS + "{c}");
+				n.breakAlign.cell = X(e.GetArgument(t), 1);
+				break;
+			case "r":
+				if (n.row.length || n.First) throw new y("BreakFirstInRow", "%1 must be at the beginning of an alignment row", e.currentCS + "{r}");
+				n.breakAlign.row = X(e.GetArgument(t));
+				break;
+			case "t":
+				if (n.table.length || n.row.length || n.First) throw new y("BreakFirstInTable", "%1 must be at the beginning of an alignment", e.currentCS + "{t}");
+				n.breakAlign.table = X(e.GetArgument(t));
+				break;
+			default: throw new y("BreakType", "First argument to %1 must be one of c, r, or t", e.currentCS);
+		}
+	},
+	MmlToken(e, t) {
+		let n = e.GetArgument(t), r = e.GetBrackets(t, "").replace(/^\s+/, ""), i = e.GetArgument(t), a = {}, o = [], s;
+		try {
+			s = e.create("node", n);
+		} catch {
+			s = null;
+		}
+		if (!s || !s.isToken) throw new y("NotMathMLToken", "%1 is not a token element", n);
+		for (; r !== "";) {
+			let t = r.match(/^([a-z]+)\s*=\s*('[^'\n]*'|"[^"\n]*"|[^ ,\n]*)[\s\n]*,?[\s\n]*/i);
+			if (!t) throw new y("InvalidMathMLAttr", "Invalid MathML attribute: %1", r.split(/[\s\n=]/)[0]);
+			if (!s.attributes.hasDefault(t[1]) && !Pe[t[1]]) throw new y("UnknownAttrForElement", "%1 is not a recognized attribute for %2", t[1], n);
+			let i = T.mmlFilterAttribute(e, t[1], t[2].replace(/^(['"])(.*)\1$/, "$2"));
+			i && (i.toLowerCase() === "true" ? i = !0 : i.toLowerCase() === "false" && (i = !1), a[t[1]] = i, o.push(t[1])), r = r.substring(t[0].length);
+		}
+		o.length && s.setProperty("keep-attrs", o.join(" "));
+		let l = e.create("text", c(i));
+		s.appendChild(l), p.setProperties(s, a), e.Push(s);
+	},
+	Strut(e, t) {
+		let n = e.create("node", "mrow"), r = e.create("node", "mpadded", [n], {
+			height: "8.6pt",
+			depth: "3pt",
+			width: 0
+		});
+		e.Push(r);
+	},
+	Phantom(e, t, n, r) {
+		let i = e.create("node", "mphantom", [e.ParseArg(t)]);
+		(n || r) && (i = e.create("node", "mpadded", [i]), r && (p.setAttribute(i, "height", 0), p.setAttribute(i, "depth", 0)), n && p.setAttribute(i, "width", 0));
+		let a = e.create("node", "TeXAtom", [i]);
+		e.Push(a);
+	},
+	Smash(e, t) {
+		let n = v.trimSpaces(e.GetBrackets(t, "")), r = e.create("node", "mpadded", [e.ParseArg(t)]);
+		switch (n) {
+			case "b":
+				p.setAttribute(r, "depth", 0);
+				break;
+			case "t":
+				p.setAttribute(r, "height", 0);
+				break;
+			default: p.setAttribute(r, "height", 0), p.setAttribute(r, "depth", 0);
+		}
+		let i = e.create("node", "TeXAtom", [r]);
+		e.Push(i);
+	},
+	Lap(e, t) {
+		let n = e.create("node", "mpadded", [e.ParseArg(t)], { width: 0 });
+		t === "\\llap" && p.setAttribute(n, "lspace", "-1width");
+		let r = e.create("node", "TeXAtom", [n]);
+		e.Push(r);
+	},
+	RaiseLower(e, t) {
+		let n = e.GetDimen(t), r = e.itemFactory.create("position").setProperties({
+			name: e.currentCS,
+			move: "vertical"
+		});
+		n.charAt(0) === "-" && (n = n.slice(1), t = t.substring(1) === "raise" ? "\\lower" : "\\raise"), t === "\\lower" ? (r.setProperty("dh", "-" + n), r.setProperty("dd", "+" + n)) : (r.setProperty("dh", "+" + n), r.setProperty("dd", "-" + n)), e.Push(r);
+	},
+	MoveLeftRight(e, t) {
+		let n = e.GetDimen(t), r = n.charAt(0) === "-" ? n.slice(1) : "-" + n;
+		if (t === "\\moveleft") {
+			let e = n;
+			n = r, r = e;
+		}
+		e.Push(e.itemFactory.create("position").setProperties({
+			name: e.currentCS,
+			move: "horizontal",
+			left: e.create("node", "mspace", [], { width: n }),
+			right: e.create("node", "mspace", [], { width: r })
+		}));
+	},
+	Hskip(e, t, n = !1) {
+		let r = e.create("node", "mspace", [], { width: e.GetDimen(t) });
+		n && p.setAttribute(r, "linebreak", "nobreak"), e.Push(r);
+	},
+	Nonscript(e, t) {
+		e.Push(e.itemFactory.create("nonscript"));
+	},
+	Rule(e, t, n) {
+		let r = {
+			width: e.GetDimen(t),
+			height: e.GetDimen(t),
+			depth: e.GetDimen(t)
+		};
+		n !== "blank" && (r.mathbackground = e.stack.env.color || "black");
+		let i = e.create("node", "mspace", [], r);
+		e.Push(i);
+	},
+	rule(e, t) {
+		let n = e.GetBrackets(t), r = e.GetDimen(t), i = e.GetDimen(t), a = e.create("node", "mspace", [], {
+			width: r,
+			height: i,
+			mathbackground: e.stack.env.color || "black"
+		});
+		n && (a = e.create("node", "mpadded", [a], { voffset: n }), n.match(/^-/) ? (p.setAttribute(a, "height", n), p.setAttribute(a, "depth", "+" + n.substring(1))) : p.setAttribute(a, "height", "+" + n)), e.Push(a);
+	},
+	MakeBig(e, t, n, r) {
+		r *= Ne;
+		let i = String(r).replace(/(\.\d\d\d).+/, "$1") + "em", a = e.GetDelimiter(t, !0), o = e.create("token", "mo", {
+			minsize: i,
+			maxsize: i,
+			fence: !0,
+			stretchy: !0,
+			symmetric: !0
+		}, a), s = e.create("node", "TeXAtom", [o], { texClass: n });
+		e.Push(s);
+	},
+	BuildRel(e, t) {
+		let n = e.ParseUpTo(t, "\\over"), r = e.ParseArg(t), i = e.create("node", "munderover");
+		p.setChild(i, 0, r), p.setChild(i, 1, null), p.setChild(i, 2, n);
+		let a = e.create("node", "TeXAtom", [i], { texClass: s.REL });
+		e.Push(a);
+	},
+	HBox(e, t, n, r) {
+		e.PushAll(T.internalMath(e, e.GetArgument(t), n, r));
+	},
+	FBox(e, t) {
+		let n = T.internalMath(e, e.GetArgument(t)), r = e.create("node", "menclose", n, { notation: "box" });
+		e.Push(r);
+	},
+	FrameBox(e, n) {
+		let r = e.GetBrackets(n), i = e.GetBrackets(n) || "c", a = T.internalMath(e, e.GetArgument(n));
+		r && (a = [e.create("node", "mpadded", a, {
+			width: r,
+			"data-align": t(i, {
+				l: "left",
+				r: "right"
+			}, "center")
+		})]);
+		let o = e.create("node", "TeXAtom", [e.create("node", "menclose", a, { notation: "box" })], { texClass: s.ORD });
+		e.Push(o);
+	},
+	MakeBox(e, n) {
+		let r = e.GetBrackets(n), i = e.GetBrackets(n, "c"), a = e.create("node", "mpadded", T.internalMath(e, e.GetArgument(n)));
+		r && p.setAttribute(a, "width", r);
+		let o = t(i.toLowerCase(), {
+			c: "center",
+			r: "right"
+		}, "");
+		o && p.setAttribute(a, "data-align", o), i.toLowerCase() !== i && p.setAttribute(a, "data-overflow", "linebreak"), e.Push(a);
+	},
+	Not(e, t) {
+		e.Push(e.itemFactory.create("not"));
+	},
+	Dots(e, t) {
+		let n = p.createEntity("2026"), r = p.createEntity("22EF"), i = e.create("token", "mo", { stretchy: !1 }, n), a = e.create("token", "mo", { stretchy: !1 }, r);
+		e.Push(e.itemFactory.create("dots").setProperties({
+			ldots: i,
+			cdots: a
+		}));
+	},
+	Matrix(e, t, n, r, i, a, o, s, c, l) {
+		let u = e.GetNext();
+		if (u === "") throw new y("MissingArgFor", "Missing argument for %1", e.currentCS);
+		u === "{" ? e.i++ : (e.string = u + "}" + e.string.slice(e.i + 1), e.i = 0);
+		let d = e.itemFactory.create("array").setProperty("requireClose", !0);
+		(n || !i) && d.setProperty("arrayPadding", ".2em .125em"), d.arraydef = {
+			rowspacing: o || "4pt",
+			columnspacing: a || "1em"
+		}, c && d.setProperty("isCases", !0), l && (d.setProperty("isNumbered", !0), d.arraydef.side = l), (n || r) && (d.setProperty("open", n), d.setProperty("close", r)), s === "D" && (d.arraydef.displaystyle = !0), i != null && (d.arraydef.columnalign = i), e.Push(d);
+	},
+	Entry(e, t) {
+		e.Push(e.itemFactory.create("cell").setProperties({
+			isEntry: !0,
+			name: t
+		}));
+		let n = e.stack.Top(), r = n.getProperty("casesEnv");
+		if (!n.getProperty("isCases") && !r) return;
+		let i = e.string, a = 0, o = -1, s = e.i, c = i.length, l = r ? RegExp(`^\\\\end\\s*\\{${r.replace(/\*/, "\\*")}\\}`) : null;
+		for (; s < c;) {
+			let t = i.charAt(s);
+			if (t === "{") a++, s++;
+			else if (t === "}") a === 0 ? c = 0 : (a--, a === 0 && o < 0 && (o = s - e.i), s++);
+			else if (t === "&" && a === 0) throw new y("ExtraAlignTab", "Extra alignment tab in \\cases text");
+			else if (t === "\\") {
+				let e = i.substring(s);
+				e.match(/^((\\cr)[^a-zA-Z]|\\\\)/) || l && e.match(l) ? c = 0 : s += 2;
+			} else s++;
+		}
+		let u = i.substring(e.i, s);
+		if (!u.match(/^\s*\\text[^a-zA-Z]/) || o !== u.replace(/\s+$/, "").length - 1) {
+			let t = T.internalMath(e, v.trimSpaces(u), 0);
+			e.PushAll(t), e.i = s;
+		}
+	},
+	Cr(e, t) {
+		e.Push(e.itemFactory.create("cell").setProperties({
+			isCR: !0,
+			name: t
+		}));
+	},
+	CrLaTeX(e, t, n = !1) {
+		let r;
+		if (!n && (e.string.charAt(e.i) === "*" && e.i++, e.string.charAt(e.i) === "[")) {
+			let n = e.GetBrackets(t, ""), [i, a] = v.matchDimen(n);
+			if (n && !i) throw new y("BracketMustBeDimension", "Bracket argument to %1 must be a dimension", e.currentCS);
+			r = i + a;
+		}
+		e.Push(e.itemFactory.create("cell").setProperties({
+			isCR: !0,
+			name: t,
+			linebreak: !0
+		}));
+		let i = e.stack.Top(), a;
+		i instanceof J ? r && i.addRowSpacing(r) : (a = e.create("node", "mspace", [], { linebreak: m.LineBreak.NEWLINE }), r && p.setAttribute(a, "data-lineleading", r), e.Push(a));
+	},
+	HLine(e, t, n) {
+		n ??= "solid";
+		let r = e.stack.Top();
+		if (!(r instanceof J) || r.Size()) throw new y("Misplaced", "Misplaced %1", e.currentCS);
+		if (!r.table.length) r.frame.push(["top", n]);
+		else {
+			let e = r.arraydef.rowlines ? r.arraydef.rowlines.split(/ /) : [];
+			for (; e.length < r.table.length;) e.push("none");
+			e[r.table.length - 1] = n, r.arraydef.rowlines = e.join(" ");
+		}
+	},
+	HFill(e, t) {
+		let n = e.stack.Top();
+		if (n instanceof J) n.hfill.push(n.Size());
+		else throw new y("UnsupportedHFill", "Unsupported use of %1", e.currentCS);
+	},
+	NewColumnType(e, t) {
+		let n = e.GetArgument(t), r = e.GetBrackets(t, "0"), i = e.GetArgument(t);
+		if (n.length !== 1) throw new y("BadColumnName", "Column specifier must be exactly one character: %1", n);
+		if (!r.match(/^\d+$/)) throw new y("PositiveIntegerArg", "Argument to %1 must be a positive integer", r);
+		let a = e.configuration.columnParser;
+		a.columnHandler[n] = (e) => a.macroColumn(e, i, parseInt(r)), e.Push(e.itemFactory.create("null"));
+	},
+	BeginEnd(e, t) {
+		let n = e.GetArgument(t);
+		if (n.match(/\\/)) throw new y("InvalidEnv", "Invalid environment name '%1'", n);
+		let r = e.configuration.handlers.get(g.ENVIRONMENT).lookup(n);
+		if (r && t === "\\end") {
+			if (!r.args[0]) {
+				let t = e.itemFactory.create("end").setProperty("name", n);
+				e.Push(t);
+				return;
+			}
+			e.stack.env.closing = n;
+		}
+		T.checkMaxMacros(e, !1), e.parse(g.ENVIRONMENT, [e, n]);
+	},
+	Array(e, t, n, r, i, a, o, s, c) {
+		i ||= e.GetArgument("\\begin{" + t.getName() + "}");
+		let l = e.itemFactory.create("array");
+		return t.getName() === "array" && l.setProperty("arrayPadding", ".5em .125em"), l.parser = e, l.arraydef = {
+			columnspacing: a || "1em",
+			rowspacing: o || "4pt"
+		}, e.configuration.columnParser.process(e, i, l), n && l.setProperty("open", e.convertDelimiter(n)), r && l.setProperty("close", e.convertDelimiter(r)), (s || "").charAt(1) === "'" && (l.arraydef["data-cramped"] = !0, s = s.charAt(0)), s === "D" ? l.arraydef.displaystyle = !0 : s && (l.arraydef.displaystyle = !1), l.arraydef.scriptlevel = +(s === "S"), c && (l.arraydef.useHeight = !1), e.Push(t), l.StartEntry(), l;
+	},
+	AlignedArray(e, t, n = "") {
+		let r = e.GetBrackets("\\begin{" + t.getName() + "}"), i = Q.Array(e, t, null, null, null, null, null, n);
+		return T.setArrayAlign(i, r);
+	},
+	IndentAlign(e, t) {
+		let n = `\\begin{${t.getName()}}`, r = e.GetBrackets(n, ""), i = e.GetBrackets(n, ""), a = e.GetBrackets(n, "");
+		if (r && !v.matchDimen(r)[0] || i && !v.matchDimen(i)[0] || a && !v.matchDimen(a)[0]) throw new y("BracketMustBeDimension", "Bracket argument to %1 must be a dimension", n);
+		let o = e.GetArgument(n);
+		if (o && !o.match(/^([lcr]{1,3})?$/)) throw new y("BadAlignment", "Alignment must be one to three copies of l, c, or r");
+		let s = [...o].map((e) => ({
+			l: "left",
+			c: "center",
+			r: "right"
+		})[e]);
+		s.length === 1 && s.push(s[0]);
+		let c = {};
+		for (let [e, t] of [
+			["indentshiftfirst", r],
+			["indentshift", i || r],
+			["indentshiftlast", a],
+			["indentalignfirst", s[0]],
+			["indentalign", s[1]],
+			["indentalignlast", s[2]]
+		]) t && (c[e] = t);
+		e.Push(e.itemFactory.create("mstyle", c, t.getName()));
+	},
+	Equation(e, t, n, r = !0) {
+		return e.configuration.mathItem.display = r, e.stack.env.display = r, T.checkEqnEnv(e), e.Push(t), e.itemFactory.create("equation", n).setProperty("name", t.getName());
+	},
+	EqnArray(e, t, n, r, i, a, o) {
+		let s = t.getName(), c = s === "gather" || s === "gather*";
+		r && T.checkEqnEnv(e, !c), e.Push(t), i = i.replace(/[^clr]/g, "").split("").join(" "), i = i.replace(/l/g, "left").replace(/r/g, "right").replace(/c/g, "center"), a = X(a);
+		let l = e.itemFactory.create("eqnarray", s, n, r, e.stack.global);
+		return l.arraydef = {
+			displaystyle: !0,
+			columnalign: i,
+			columnspacing: o || "1em",
+			rowspacing: "3pt",
+			"data-break-align": a,
+			side: e.options.tagSide,
+			minlabelspacing: e.options.tagIndent
+		}, c && l.setProperty("nestable", !0), l;
+	},
+	HandleNoTag(e, t) {
+		e.tags.notag();
+	},
+	HandleLabel(e, t) {
+		let n = e.GetArgument(t);
+		if (n !== "" && !e.tags.refUpdate) {
+			if (e.tags.label) throw new y("MultipleCommand", "Multiple %1", e.currentCS);
+			if (e.tags.label = n, (e.tags.allLabels[n] || e.tags.labels[n]) && !e.options.ignoreDuplicateLabels) throw new y("MultipleLabel", "Label '%1' multiply defined", n);
+			e.tags.labels[n] = new E();
+		}
+	},
+	HandleRef(e, t, n) {
+		let r = e.GetArgument(t), i = e.tags.allLabels[r] || e.tags.labels[r];
+		i ||= (e.tags.refUpdate || (e.tags.redo = !0), new E());
+		let a = i.tag;
+		n && (a = e.tags.formatRef(a));
+		let o = e.create("node", "mrow", T.internalMath(e, Array.isArray(a) ? a.join("") : a), {
+			href: e.tags.formatUrl(i.id, e.options.baseURL),
+			class: "MathJax_ref"
+		});
+		e.Push(o);
+	},
+	Macro(e, t, n, r, i) {
+		if (r) {
+			let a = [];
+			if (i != null) {
+				let n = e.GetBrackets(t);
+				a.push(n ?? i);
+			}
+			for (let n = a.length; n < r; n++) a.push(e.GetArgument(t));
+			n = T.substituteArgs(e, a, n);
+		}
+		e.string = T.addArgs(e, n, e.string.slice(e.i)), e.i = 0, T.checkMaxMacros(e);
+	},
+	MathChoice(e, t) {
+		let n = e.ParseArg(t), r = e.ParseArg(t), i = e.ParseArg(t), a = e.ParseArg(t);
+		e.Push(e.create("node", "MathChoice", [
+			n,
+			r,
+			i,
+			a
+		]));
+	}
+}, $ = m.Variant, Fe = {
+	variable(e, t) {
+		let n = T.getFontDef(e), r = e.stack.env;
+		if (r.multiLetterIdentifiers && r.font !== "" && (t = e.string.substring(e.i - 1).match(r.multiLetterIdentifiers)?.[0] || t, e.i += t.length - 1, n.mathvariant === $.NORMAL && r.noAutoOP && t.length > 1 && (n.autoOP = !1)), !n.mathvariant && T.isLatinOrGreekChar(t)) {
+			let r = e.configuration.mathStyle(t);
+			r && (n.mathvariant = r);
+		}
+		let i = e.create("token", "mi", n, t);
+		e.Push(i);
+	},
+	digit(e, t) {
+		let n = e.configuration.options.numberPattern, r = e.string.slice(e.i - 1).match(n);
+		if (!r) return !1;
+		let i = T.getFontDef(e), a = e.create("token", "mn", i, r[0].replace(/[{}]/g, ""));
+		return e.i += r[0].length - 1, e.Push(a), !0;
+	},
+	controlSequence(e, t) {
+		let n = e.GetCS();
+		e.parse(g.MACRO, [e, n]);
+	},
+	lcGreek(e, t) {
+		let n = { mathvariant: e.configuration.mathStyle(t.char) || $.ITALIC }, r = e.create("token", "mi", n, t.char);
+		e.Push(r);
+	},
+	ucGreek(e, t) {
+		let n = { mathvariant: e.stack.env.font || e.configuration.mathStyle(t.char, !0) || $.NORMAL }, r = e.create("token", "mi", n, t.char);
+		e.Push(r);
+	},
+	mathchar0mi(e, t) {
+		let n = t.attributes || { mathvariant: $.ITALIC }, r = e.create("token", "mi", n, t.char);
+		e.Push(r);
+	},
+	mathchar0mo(e, t) {
+		let n = t.attributes || {};
+		n.stretchy = !1;
+		let r = e.create("token", "mo", n, t.char);
+		p.setProperty(r, "fixStretchy", !0), e.configuration.addNode("fixStretchy", r), e.Push(r);
+	},
+	mathchar7(e, t) {
+		let n = t.attributes || { mathvariant: $.NORMAL };
+		e.stack.env.font && (n.mathvariant = e.stack.env.font);
+		let r = e.create("token", "mi", n, t.char);
+		e.Push(r);
+	},
+	delimiter(e, t) {
+		let n = t.attributes || {};
+		n = Object.assign({
+			fence: !1,
+			stretchy: !1
+		}, n);
+		let r = e.create("token", "mo", n, t.char);
+		e.Push(r);
+	},
+	environment(e, t, n, r) {
+		let i = e.itemFactory.create("begin").setProperty("name", t);
+		e.Push(n(e, i, ...r.slice(1)));
+	}
+};
+//#endregion
+export { de as A, N as B, we as C, me as D, pe as E, ce as F, x as G, O as H, se as I, v as J, b as K, le as L, B as M, V as N, Ce as O, L as P, p as Q, R, ve as S, be as T, j as U, M as V, T as W, g as X, h as Y, m as Z, Y as _, q as a, ge as b, he as c, je as d, Me as f, Ee as g, ye as h, J as i, fe as j, G as k, Ae as l, K as m, Q as n, xe as o, De as p, y as q, X as r, Te as s, Fe as t, Se as u, ke as v, _e as w, W as x, Oe as y, oe as z };