manim-web 0.3.20 → 0.3.22

package/dist/tex-Cd_bTYKG.js

@@ -0,0 +1,1427 @@
+import { a as e, o as t, r as n, t as r } from "./Options-DMK2wYar.js";
+import { r as i } from "./mathjax-b-GTdZgw.js";
+import { a, h as o, l as s, r as c } from "./mo-D4wFHS6V.js";
+import { t as l } from "./InputJax-jNvwWU5P.js";
+import { a as u, t as d } from "./Factory-Ba6Nqb3M.js";
+import { A as ee, C as te, D as ne, E as f, F as re, G as ie, H as ae, I as oe, J as se, K as ce, L as le, M as ue, O as p, P as m, Q as h, R as de, S as fe, T as pe, U as g, W as _, X as v, Y as y, Z as b, _ as x, a as S, b as C, c as w, d as T, f as E, g as D, h as O, i as k, j as me, k as A, l as j, m as M, n as N, o as P, p as F, q as I, s as L, t as R, u as z, v as B, w as he, x as V, y as H, z as U } from "./ParseMethods-Dt5bYDSZ.js";
+import { n as W, r as ge } from "./lengths-D2zTYMUu.js";
+//#region node_modules/@mathjax/src/mjs/core/FindMath.js
+var G = class {
+	constructor(e) {
+		let n = this.constructor;
+		this.options = t(r({}, n.OPTIONS), e);
+	}
+};
+G.OPTIONS = {};
+//#endregion
+//#region node_modules/@mathjax/src/mjs/input/tex/FindTeX.js
+var K = class extends G {
+	constructor(e) {
+		super(e), this.getPatterns();
+	}
+	getPatterns() {
+		let e = this.options, t = [], n = [], r = [];
+		this.end = {}, this.env = this.sub = 0;
+		let i = 1;
+		e.inlineMath.forEach((e) => this.addPattern(t, e, !1)), e.displayMath.forEach((e) => this.addPattern(t, e, !0)), t.length && n.push(t.sort(a).join("|")), e.processEnvironments && (n.push("\\\\begin\\s*\\{([^}]*)\\}"), this.env = i, i++), e.processEscapes && r.push("\\\\([\\\\$])"), e.processRefs && r.push("(\\\\(?:eq)?ref\\s*\\{[^}]*\\})"), r.length && (n.push("(" + r.join("|") + ")"), this.sub = i), this.start = new RegExp(n.join("|"), "g"), this.hasPatterns = n.length > 0;
+	}
+	addPattern(e, t, n) {
+		let [r, i] = t;
+		e.push(c(r)), this.end[r] = [
+			i,
+			n,
+			this.endPattern(i)
+		];
+	}
+	endPattern(e, t) {
+		return RegExp((t || c(e)) + "|\\\\(?:[a-zA-Z]|.)|[{}]", "g");
+	}
+	findEnd(e, t, n, r) {
+		let [i, a, o] = r, s = o.lastIndex = n.index + n[0].length, c, l = 0;
+		for (; c = o.exec(e);) if ((c[1] || c[0]) === i && l === 0) return u(n[0], e.substring(s, c.index), c[0], t, n.index, c.index + c[0].length, a);
+		else c[0] === "{" ? l++ : c[0] === "}" && l && l--;
+		return null;
+	}
+	findMathInString(e, t, n) {
+		let r, i;
+		for (this.start.lastIndex = 0; r = this.start.exec(n);) {
+			if (r[this.env] !== void 0 && this.env) {
+				let e = "\\\\end\\s*(\\{" + c(r[this.env]) + "\\})";
+				i = this.findEnd(n, t, r, [
+					"{" + r[this.env] + "}",
+					!0,
+					this.endPattern(null, e)
+				]), i && (i.math = i.open + i.math + i.close, i.open = i.close = "");
+			} else if (r[this.sub] !== void 0 && this.sub) {
+				let e = r[this.sub], n = r.index + r[this.sub].length;
+				i = e.length === 2 ? u("\\", e.substring(1), "", t, r.index, n) : u("", e, "", t, r.index, n, !1);
+			} else i = this.findEnd(n, t, r, this.end[r[0]]);
+			i && (e.push(i), this.start.lastIndex = i.end.n);
+		}
+	}
+	findMath(e) {
+		let t = [];
+		if (this.hasPatterns) for (let n = 0, r = e.length; n < r; n++) this.findMathInString(t, n, e[n]);
+		return t;
+	}
+};
+K.OPTIONS = {
+	inlineMath: [["\\(", "\\)"]],
+	displayMath: [["$$", "$$"], ["\\[", "\\]"]],
+	processEscapes: !0,
+	processEnvironments: !0,
+	processRefs: !0
+};
+//#endregion
+//#region node_modules/@mathjax/src/mjs/input/tex/FilterUtil.js
+function _e(e, t, n) {
+	let r = t.attributes, i = n.attributes;
+	e.forEach((e) => {
+		let t = i.getExplicit(e);
+		t != null && r.set(e, t);
+	});
+}
+function ve(e, t) {
+	let n = (e, t) => e.getExplicitNames().filter((n) => n !== t && (n !== "stretchy" || e.getExplicit("stretchy")) && n !== "data-latex" && n !== "data-latex-item"), r = e.attributes, i = t.attributes, a = n(r, "lspace"), o = n(i, "rspace");
+	if (a.length !== o.length) return !1;
+	for (let e of a) if (r.getExplicit(e) !== i.getExplicit(e)) return !1;
+	return !0;
+}
+function ye(e, t, n) {
+	let r = [];
+	for (let i of e.getList("m" + t + n)) {
+		let a = i.childNodes;
+		if (a[i[t]] && a[i[n]]) continue;
+		let o = i.parent, s = a[i[t]] ? e.nodeFactory.create("node", "m" + t, [a[i.base], a[i[t]]]) : e.nodeFactory.create("node", "m" + n, [a[i.base], a[i[n]]]);
+		h.copyAttributes(i, s), o.replaceChild(s, i), r.push(i);
+	}
+	e.removeFromList("m" + t + n, r);
+}
+function q(e, t, n) {
+	let r = [];
+	for (let i of e.getList(t)) {
+		if (i.attributes.get("displaystyle")) continue;
+		let t = i.childNodes[i.base], a = t.coreMO();
+		if (t.getProperty("movablelimits") && !a.attributes.hasExplicit("movablelimits")) {
+			let t = e.nodeFactory.create("node", n, i.childNodes);
+			h.copyAttributes(i, t), i.parent.replaceChild(t, i), r.push(i);
+		}
+	}
+	e.removeFromList(t, r);
+}
+var J = {
+	cleanStretchy(e) {
+		let t = e.data;
+		for (let e of t.getList("fixStretchy")) h.getProperty(e, "fixStretchy") && (h.getForm(e)?.[3]?.stretchy && h.setAttribute(e, "stretchy", !1), h.removeProperties(e, "fixStretchy"));
+	},
+	cleanAttributes(e) {
+		e.data.root.walkTree((e) => {
+			let t = new Set((e.getProperty("keep-attrs") || "").split(/ /)), n = e.attributes;
+			n.unset(b.Attr.LATEXITEM);
+			for (let e of n.getExplicitNames()) !t.has(e) && n.get(e) === n.getInherited(e) && n.unset(e);
+		});
+	},
+	combineRelations(e) {
+		let t = [];
+		for (let n of e.data.getList("mo")) {
+			if (n.getProperty("relationsCombined") || !n.parent || n.parent && !h.isType(n.parent, "mrow") || h.getTexClass(n) !== o.REL) continue;
+			let e = n.parent, r, i = e.childNodes, a = i.indexOf(n) + 1, s = h.getProperty(n, "variantForm");
+			for (; a < i.length && (r = i[a]) && h.isType(r, "mo") && h.getTexClass(r) === o.REL;) if (s === h.getProperty(r, "variantForm") && ve(n, r)) {
+				h.appendChildren(n, h.getChildren(r)), _e(["stretchy", "rspace"], n, r);
+				for (let e of r.getPropertyNames()) n.setProperty(e, r.getProperty(e));
+				r.attributes.get("data-latex") && n.attributes.set("data-latex", n.attributes.get("data-latex") + r.attributes.get("data-latex")), i.splice(a, 1), t.push(r), r.parent = null, r.setProperty("relationsCombined", !0), n.setProperty("texClass", o.REL);
+			} else {
+				n.attributes.hasExplicit("rspace") || h.setAttribute(n, "rspace", "0pt"), r.attributes.hasExplicit("lspace") || h.setAttribute(r, "lspace", "0pt");
+				break;
+			}
+			n.attributes.setInherited("form", n.getForms()[0]);
+		}
+		e.data.removeFromList("mo", t);
+	},
+	cleanSubSup(e) {
+		let t = e.data;
+		t.error || (ye(t, "sub", "sup"), ye(t, "under", "over"));
+	},
+	moveLimits(e) {
+		let t = e.data;
+		q(t, "munderover", "msubsup"), q(t, "munder", "msub"), q(t, "mover", "msup");
+	},
+	setInherited(e) {
+		e.data.root.setInheritedAttributes({}, e.math.display, 0, !1);
+	},
+	checkScriptlevel(e) {
+		let t = e.data, n = [];
+		for (let e of t.getList("mstyle")) {
+			if (e.childNodes[0].childNodes.length !== 1) continue;
+			let t = e.attributes;
+			for (let e of ["displaystyle", "scriptlevel"]) t.getExplicit(e) === t.getInherited(e) && t.unset(e);
+			let r = t.getExplicitNames();
+			if (r.filter((e) => e.substring(0, 10) !== "data-latex").length === 0) {
+				let i = e.childNodes[0].childNodes[0];
+				r.forEach((e) => i.attributes.set(e, t.get(e))), e.parent.replaceChild(i, e), n.push(e);
+			}
+		}
+		t.removeFromList("mstyle", n);
+	}
+}, be = class extends ce {}, Y = class extends d {
+	constructor() {
+		super(...arguments), this.defaultKind = "dummy", this.configuration = null;
+	}
+};
+Y.DefaultStackItems = { [be.prototype.kind]: be };
+//#endregion
+//#region node_modules/@mathjax/src/mjs/input/tex/NodeFactory.js
+var xe = class e {
+	constructor() {
+		this.mmlFactory = null, this.factory = {
+			node: e.createNode,
+			token: e.createToken,
+			text: e.createText,
+			error: e.createError
+		};
+	}
+	static createNode(e, t, n = [], r = {}, i) {
+		let a = e.mmlFactory.create(t);
+		return a.setChildren(n), i && a.appendChild(i), h.setProperties(a, r), a;
+	}
+	static createToken(e, t, n = {}, r = "") {
+		let i = e.create("text", r);
+		return e.create("node", t, [], n, i);
+	}
+	static createText(e, t) {
+		return t == null ? null : e.mmlFactory.create("text").setText(t);
+	}
+	static createError(e, t) {
+		let n = e.create("text", t), r = e.create("node", "mtext", [], {}, n);
+		return e.create("node", "merror", [r], { "data-mjx-error": t });
+	}
+	setMmlFactory(e) {
+		this.mmlFactory = e;
+	}
+	set(e, t) {
+		this.factory[e] = t;
+	}
+	setCreators(e) {
+		for (let t in e) this.set(t, e[t]);
+	}
+	create(e, ...t) {
+		let n = (this.factory[e] || this.factory.node)(this, t[0], ...t.slice(1));
+		return e === "node" && this.configuration.addNode(t[0], n), n;
+	}
+	get(e) {
+		return this.factory[e];
+	}
+}, Se = class {
+	constructor() {
+		this.columnHandler = {
+			l: (e) => e.calign[e.j++] = "left",
+			c: (e) => e.calign[e.j++] = "center",
+			r: (e) => e.calign[e.j++] = "right",
+			p: (e) => this.getColumn(e, "top"),
+			m: (e) => this.getColumn(e, "middle"),
+			b: (e) => this.getColumn(e, "bottom"),
+			w: (e) => this.getColumn(e, "top", ""),
+			W: (e) => this.getColumn(e, "top", ""),
+			"|": (e) => this.addRule(e, "solid"),
+			":": (e) => this.addRule(e, "dashed"),
+			">": (e) => e.cstart[e.j] = (e.cstart[e.j] || "") + this.getBraces(e),
+			"<": (e) => e.cend[e.j - 1] = (e.cend[e.j - 1] || "") + this.getBraces(e),
+			"@": (e) => this.addAt(e, this.getBraces(e)),
+			"!": (e) => this.addBang(e, this.getBraces(e)),
+			"*": (e) => this.repeat(e),
+			P: (e) => this.macroColumn(e, ">{$}p{#1}<{$}", 1),
+			M: (e) => this.macroColumn(e, ">{$}m{#1}<{$}", 1),
+			B: (e) => this.macroColumn(e, ">{$}b{#1}<{$}", 1),
+			" ": (e) => {}
+		}, this.MAXCOLUMNS = 1e4;
+	}
+	process(e, t, n) {
+		let r = {
+			parser: e,
+			template: t,
+			i: 0,
+			j: 0,
+			c: "",
+			cwidth: [],
+			calign: [],
+			cspace: [],
+			clines: [],
+			cstart: n.cstart,
+			cend: n.cend,
+			ralign: n.ralign,
+			cextra: n.cextra
+		}, i = 0;
+		for (; r.i < r.template.length;) {
+			if (i++ > this.MAXCOLUMNS) throw new I("MaxColumns", "Too many column specifiers (perhaps looping column definitions?)");
+			let e = r.template.codePointAt(r.i), t = r.c = String.fromCodePoint(e);
+			if (r.i += t.length, !Object.hasOwn(this.columnHandler, t)) throw new I("BadPreamToken", "Illegal pream-token (%1)", t);
+			this.columnHandler[t](r);
+		}
+		this.setColumnAlign(r, n), this.setColumnWidths(r, n), this.setColumnSpacing(r, n), this.setColumnLines(r, n), this.setPadding(r, n);
+	}
+	setColumnAlign(e, t) {
+		t.arraydef.columnalign = e.calign.join(" ");
+	}
+	setColumnWidths(e, t) {
+		if (!e.cwidth.length) return;
+		let n = [...e.cwidth];
+		n.length < e.calign.length && n.push("auto"), t.arraydef.columnwidth = n.map((e) => e || "auto").join(" ");
+	}
+	setColumnSpacing(e, t) {
+		if (!e.cspace.length) return;
+		let n = [...e.cspace];
+		n.length < e.calign.length && n.push("1em"), t.arraydef.columnspacing = n.slice(1).map((e) => e || "1em").join(" ");
+	}
+	setColumnLines(e, t) {
+		if (!e.clines.length) return;
+		let n = [...e.clines];
+		n[0] && t.frame.push(["left", n[0]]), n.length > e.calign.length ? t.frame.push(["right", n.pop()]) : n.length < e.calign.length && n.push("none"), n.length > 1 && (t.arraydef.columnlines = n.slice(1).map((e) => e || "none").join(" "));
+	}
+	setPadding(e, t) {
+		if (!e.cextra[0] && !e.cextra[e.calign.length - 1]) return;
+		let n = e.calign.length - 1, r = e.cspace, i = e.cextra[n] ? r[n] : null;
+		t.arraydef["data-array-padding"] = `${r[0] || ".5em"} ${i || ".5em"}`;
+	}
+	getColumn(e, t, n = "left") {
+		e.calign[e.j] = n || this.getAlign(e), e.cwidth[e.j] = this.getDimen(e), e.ralign[e.j] = [
+			t,
+			e.cwidth[e.j],
+			e.calign[e.j]
+		], e.j++;
+	}
+	getDimen(e) {
+		let t = this.getBraces(e);
+		if (!se.matchDimen(t)[0]) throw new I("MissingColumnDimOrUnits", "Missing dimension or its units for %1 column declaration", e.c);
+		return t;
+	}
+	getAlign(e) {
+		return n(this.getBraces(e).toLowerCase(), {
+			l: "left",
+			c: "center",
+			r: "right"
+		}, "");
+	}
+	getBraces(e) {
+		for (; e.template[e.i] === " ";) e.i++;
+		if (e.i >= e.template.length) throw new I("MissingArgForColumn", "Missing argument for %1 column declaration", e.c);
+		if (e.template[e.i] !== "{") return e.template[e.i++];
+		let t = ++e.i, n = 1;
+		for (; e.i < e.template.length;) switch (e.template.charAt(e.i++)) {
+			case "\\":
+				e.i++;
+				break;
+			case "{":
+				n++;
+				break;
+			case "}":
+				if (--n === 0) return e.template.slice(t, e.i - 1);
+				break;
+		}
+		throw new I("MissingCloseBrace", "Missing close brace");
+	}
+	macroColumn(e, t, n) {
+		let r = [];
+		for (; n > 0 && n--;) r.push(this.getBraces(e));
+		e.template = _.substituteArgs(e.parser, r, t) + e.template.slice(e.i), e.i = 0;
+	}
+	addRule(e, t) {
+		e.clines[e.j] && this.addAt(e, "\\,"), e.clines[e.j] = t, e.cspace[e.j] === "0" && (e.cstart[e.j] = "\\hspace{.5em}");
+	}
+	addAt(e, t) {
+		let { cstart: n, cspace: r, j: i } = e;
+		e.cextra[i] = !0, e.calign[i] = "center", e.clines[i] && (r[i] === ".5em" ? n[i - 1] += "\\hspace{.25em}" : r[i] || (e.cend[i - 1] = (e.cend[i - 1] || "") + "\\hspace{.5em}")), n[i] = t, r[i] = "0", r[++e.j] = "0";
+	}
+	addBang(e, t) {
+		let { cstart: n, cspace: r, j: i } = e;
+		e.cextra[i] = !0, e.calign[i] = "center", n[i] = (r[i] === "0" && e.clines[i] ? "\\hspace{.25em}" : "") + t, r[i] || (r[i] = ".5em"), r[++e.j] = ".5em";
+	}
+	repeat(e) {
+		let t = this.getBraces(e), n = this.getBraces(e), r = parseInt(t);
+		if (String(r) !== t) throw new I("ColArgNotNum", "First argument to %1 column specifier must be a number", "*");
+		e.template = Array(r).fill(n).join("") + e.template.substring(e.i), e.i = 0;
+	}
+}, X = b.Variant, Ce = class e {
+	constructor(t, n = []) {
+		this.options = {}, this.columnParser = new Se(), this.packageData = /* @__PURE__ */ new Map(), this.parsers = [], this.root = null, this.nodeLists = {}, this.error = !1, this.handlers = t.handlers, this.nodeFactory = new xe(), this.nodeFactory.configuration = this, this.nodeFactory.setCreators(t.nodes), this.itemFactory = new Y(t.items), this.itemFactory.configuration = this, r(this.options, ...n), r(this.options, t.options), this.mathStyle = e.getVariant.get(this.options.mathStyle) || e.getVariant.get("TeX");
+	}
+	pushParser(e) {
+		this.parsers.unshift(e);
+	}
+	popParser() {
+		this.parsers.shift();
+	}
+	get parser() {
+		return this.parsers[0];
+	}
+	clear() {
+		this.parsers = [], this.root = null, this.nodeLists = {}, this.error = !1, this.tags.resetTag();
+	}
+	addNode(e, t) {
+		let n = this.nodeLists[e];
+		if (n ||= this.nodeLists[e] = [], n.push(t), t.kind !== e) {
+			let n = h.getProperty(t, "in-lists") || "", r = (n ? n.split(/,/) : []).concat(e).join(",");
+			h.setProperty(t, "in-lists", r);
+		}
+	}
+	getList(e) {
+		let t = this.nodeLists[e] || [], n = [];
+		for (let e of t) this.inTree(e) && n.push(e);
+		return this.nodeLists[e] = n, n;
+	}
+	removeFromList(e, t) {
+		let n = this.nodeLists[e] || [];
+		for (let e of t) {
+			let t = n.indexOf(e);
+			t >= 0 && n.splice(t, 1);
+		}
+	}
+	inTree(e) {
+		for (; e && e !== this.root;) e = e.parent;
+		return !!e;
+	}
+};
+Ce.getVariant = new Map([
+	["TeX", (e, t) => t && e.match(/^[\u0391-\u03A9\u03F4]/) ? X.NORMAL : ""],
+	["ISO", (e) => X.ITALIC],
+	["French", (e) => e.normalize("NFD").match(/^[a-z]/) ? X.ITALIC : X.NORMAL],
+	["upright", (e) => X.NORMAL]
+]);
+//#endregion
+//#region node_modules/@mathjax/src/mjs/input/tex/base/BaseMappings.js
+var Z = ge(W.thickmathspace), Q = b.Variant;
+new U("letter", R.variable, /[a-z]/i), new U("digit", R.digit, /[0-9.,]/), new U("command", R.controlSequence, /^\\/), new de("special", {
+	"{": N.Open,
+	"}": N.Close,
+	"~": N.Tilde,
+	"^": N.Superscript,
+	_: N.Subscript,
+	"|": N.Bar,
+	" ": N.Space,
+	"	": N.Space,
+	"\r": N.Space,
+	"\n": N.Space,
+	"'": N.Prime,
+	"%": N.Comment,
+	"&": N.Entry,
+	"#": N.Hash,
+	"\xA0": N.Space,
+	"’": N.Prime
+}), new m("lcGreek", R.lcGreek, {
+	alpha: "α",
+	beta: "β",
+	gamma: "γ",
+	delta: "δ",
+	epsilon: "ϵ",
+	zeta: "ζ",
+	eta: "η",
+	theta: "θ",
+	iota: "ι",
+	kappa: "κ",
+	lambda: "λ",
+	mu: "μ",
+	nu: "ν",
+	xi: "ξ",
+	omicron: "ο",
+	pi: "π",
+	rho: "ρ",
+	sigma: "σ",
+	tau: "τ",
+	upsilon: "υ",
+	phi: "ϕ",
+	chi: "χ",
+	psi: "ψ",
+	omega: "ω",
+	varepsilon: "ε",
+	vartheta: "ϑ",
+	varpi: "ϖ",
+	varrho: "ϱ",
+	varsigma: "ς",
+	varphi: "φ"
+}), new m("ucGreek", R.ucGreek, {
+	Gamma: "Γ",
+	Delta: "Δ",
+	Theta: "Θ",
+	Lambda: "Λ",
+	Xi: "Ξ",
+	Pi: "Π",
+	Sigma: "Σ",
+	Upsilon: "Υ",
+	Phi: "Φ",
+	Psi: "Ψ",
+	Omega: "Ω"
+}), new m("mathchar0mi", R.mathchar0mi, {
+	AA: "Å",
+	S: ["§", { mathvariant: Q.NORMAL }],
+	aleph: ["ℵ", { mathvariant: Q.NORMAL }],
+	hbar: ["ℏ", { variantForm: !0 }],
+	imath: "ı",
+	jmath: "ȷ",
+	ell: "ℓ",
+	wp: ["℘", { mathvariant: Q.NORMAL }],
+	Re: ["ℜ", { mathvariant: Q.NORMAL }],
+	Im: ["ℑ", { mathvariant: Q.NORMAL }],
+	partial: ["∂", { mathvariant: Q.ITALIC }],
+	infty: ["∞", { mathvariant: Q.NORMAL }],
+	prime: ["′", { variantForm: !0 }],
+	emptyset: ["∅", { mathvariant: Q.NORMAL }],
+	nabla: ["∇", { mathvariant: Q.NORMAL }],
+	top: ["⊤", { mathvariant: Q.NORMAL }],
+	bot: ["⊥", { mathvariant: Q.NORMAL }],
+	angle: ["∠", { mathvariant: Q.NORMAL }],
+	triangle: ["△", { mathvariant: Q.NORMAL }],
+	backslash: ["\\", { mathvariant: Q.NORMAL }],
+	forall: ["∀", { mathvariant: Q.NORMAL }],
+	exists: ["∃", { mathvariant: Q.NORMAL }],
+	neg: ["¬", { mathvariant: Q.NORMAL }],
+	lnot: ["¬", { mathvariant: Q.NORMAL }],
+	flat: ["♭", { mathvariant: Q.NORMAL }],
+	natural: ["♮", { mathvariant: Q.NORMAL }],
+	sharp: ["♯", { mathvariant: Q.NORMAL }],
+	clubsuit: ["♣", { mathvariant: Q.NORMAL }],
+	diamondsuit: ["♢", { mathvariant: Q.NORMAL }],
+	heartsuit: ["♡", { mathvariant: Q.NORMAL }],
+	spadesuit: ["♠", { mathvariant: Q.NORMAL }]
+}), new m("mathchar0mo", R.mathchar0mo, {
+	surd: ["√", { symmetric: !0 }],
+	coprod: ["∐", { movesupsub: !0 }],
+	bigvee: ["⋁", { movesupsub: !0 }],
+	bigwedge: ["⋀", { movesupsub: !0 }],
+	biguplus: ["⨄", { movesupsub: !0 }],
+	bigcap: ["⋂", { movesupsub: !0 }],
+	bigcup: ["⋃", { movesupsub: !0 }],
+	int: "∫",
+	intop: ["∫", {
+		movesupsub: !0,
+		movablelimits: !0
+	}],
+	iint: "∬",
+	iiint: "∭",
+	prod: ["∏", { movesupsub: !0 }],
+	sum: ["∑", { movesupsub: !0 }],
+	bigotimes: ["⨂", { movesupsub: !0 }],
+	bigoplus: ["⨁", { movesupsub: !0 }],
+	bigodot: ["⨀", { movesupsub: !0 }],
+	oint: "∮",
+	ointop: ["∮", {
+		movesupsub: !0,
+		movablelimits: !0
+	}],
+	oiint: "∯",
+	oiiint: "∰",
+	bigsqcup: ["⨆", { movesupsub: !0 }],
+	smallint: ["∫", { largeop: !1 }],
+	triangleleft: "◃",
+	triangleright: "▹",
+	bigtriangleup: "△",
+	bigtriangledown: "▽",
+	wedge: "∧",
+	land: "∧",
+	vee: "∨",
+	lor: "∨",
+	cap: "∩",
+	cup: "∪",
+	ddagger: "‡",
+	dagger: "†",
+	sqcap: "⊓",
+	sqcup: "⊔",
+	uplus: "⊎",
+	amalg: "⨿",
+	diamond: "⋄",
+	bullet: "∙",
+	wr: "≀",
+	div: "÷",
+	odot: ["⊙", { largeop: !1 }],
+	oslash: ["⊘", { largeop: !1 }],
+	otimes: ["⊗", { largeop: !1 }],
+	ominus: ["⊖", { largeop: !1 }],
+	oplus: ["⊕", { largeop: !1 }],
+	mp: "∓",
+	pm: "±",
+	circ: "∘",
+	bigcirc: "◯",
+	setminus: "∖",
+	cdot: "⋅",
+	ast: "∗",
+	times: "×",
+	star: "⋆",
+	propto: "∝",
+	sqsubseteq: "⊑",
+	sqsupseteq: "⊒",
+	parallel: "∥",
+	mid: "∣",
+	dashv: "⊣",
+	vdash: "⊢",
+	leq: "≤",
+	le: "≤",
+	geq: "≥",
+	ge: "≥",
+	lt: "<",
+	gt: ">",
+	succ: "≻",
+	prec: "≺",
+	approx: "≈",
+	succeq: "⪰",
+	preceq: "⪯",
+	supset: "⊃",
+	subset: "⊂",
+	supseteq: "⊇",
+	subseteq: "⊆",
+	in: "∈",
+	ni: "∋",
+	notin: "∉",
+	owns: "∋",
+	gg: "≫",
+	ll: "≪",
+	sim: "∼",
+	simeq: "≃",
+	perp: "⟂",
+	equiv: "≡",
+	asymp: "≍",
+	smile: "⌣",
+	frown: "⌢",
+	ne: "≠",
+	neq: "≠",
+	cong: "≅",
+	doteq: "≐",
+	bowtie: "⋈",
+	models: "⊧",
+	notChar: "⧸",
+	Leftrightarrow: "⇔",
+	Leftarrow: "⇐",
+	Rightarrow: "⇒",
+	leftrightarrow: "↔",
+	leftarrow: "←",
+	gets: "←",
+	rightarrow: "→",
+	to: ["→", { accent: !1 }],
+	mapsto: "↦",
+	leftharpoonup: "↼",
+	leftharpoondown: "↽",
+	rightharpoonup: "⇀",
+	rightharpoondown: "⇁",
+	nearrow: "↗",
+	searrow: "↘",
+	nwarrow: "↖",
+	swarrow: "↙",
+	rightleftharpoons: "⇌",
+	hookrightarrow: "↪",
+	hookleftarrow: "↩",
+	longleftarrow: "⟵",
+	Longleftarrow: "⟸",
+	longrightarrow: "⟶",
+	Longrightarrow: "⟹",
+	Longleftrightarrow: "⟺",
+	longleftrightarrow: "⟷",
+	longmapsto: "⟼",
+	ldots: "…",
+	cdots: "⋯",
+	vdots: "⋮",
+	ddots: "⋱",
+	iddots: "⋰",
+	dotsc: "…",
+	dotsb: "⋯",
+	dotsm: "⋯",
+	dotsi: "⋯",
+	dotso: "…",
+	ldotp: [".", { texClass: o.PUNCT }],
+	cdotp: ["⋅", { texClass: o.PUNCT }],
+	colon: [":", { texClass: o.PUNCT }]
+}), new m("mathchar7", R.mathchar7, {
+	_: "_",
+	"#": "#",
+	$: "$",
+	"%": "%",
+	"&": "&",
+	And: "&"
+}), new oe("delimiter", R.delimiter, {
+	"(": "(",
+	")": ")",
+	"[": "[",
+	"]": "]",
+	"<": "⟨",
+	">": "⟩",
+	"\\lt": "⟨",
+	"\\gt": "⟩",
+	"/": "/",
+	"|": ["|", { texClass: o.ORD }],
+	".": "",
+	"\\lmoustache": "⎰",
+	"\\rmoustache": "⎱",
+	"\\lgroup": "⟮",
+	"\\rgroup": "⟯",
+	"\\arrowvert": "⏐",
+	"\\Arrowvert": "‖",
+	"\\bracevert": "⎪",
+	"\\Vert": ["‖", { texClass: o.ORD }],
+	"\\|": ["‖", { texClass: o.ORD }],
+	"\\vert": ["|", { texClass: o.ORD }],
+	"\\uparrow": "↑",
+	"\\downarrow": "↓",
+	"\\updownarrow": "↕",
+	"\\Uparrow": "⇑",
+	"\\Downarrow": "⇓",
+	"\\Updownarrow": "⇕",
+	"\\backslash": "\\",
+	"\\rangle": "⟩",
+	"\\langle": "⟨",
+	"\\rbrace": "}",
+	"\\lbrace": "{",
+	"\\}": "}",
+	"\\{": "{",
+	"\\rceil": "⌉",
+	"\\lceil": "⌈",
+	"\\rfloor": "⌋",
+	"\\lfloor": "⌊",
+	"\\lbrack": "[",
+	"\\rbrack": "]"
+}), new re("macros", {
+	displaystyle: [
+		N.SetStyle,
+		"D",
+		!0,
+		0
+	],
+	textstyle: [
+		N.SetStyle,
+		"T",
+		!1,
+		0
+	],
+	scriptstyle: [
+		N.SetStyle,
+		"S",
+		!1,
+		1
+	],
+	scriptscriptstyle: [
+		N.SetStyle,
+		"SS",
+		!1,
+		2
+	],
+	rm: [N.SetFont, Q.NORMAL],
+	mit: [N.SetFont, Q.ITALIC],
+	oldstyle: [N.SetFont, Q.OLDSTYLE],
+	cal: [N.SetFont, Q.CALLIGRAPHIC],
+	it: [N.SetFont, Q.MATHITALIC],
+	bf: [N.SetFont, Q.BOLD],
+	sf: [N.SetFont, Q.SANSSERIF],
+	tt: [N.SetFont, Q.MONOSPACE],
+	frak: [N.MathFont, Q.FRAKTUR],
+	Bbb: [N.MathFont, Q.DOUBLESTRUCK],
+	mathrm: [N.MathFont, Q.NORMAL],
+	mathup: [N.MathFont, Q.NORMAL],
+	mathnormal: [N.MathFont, ""],
+	mathbf: [N.MathFont, Q.BOLD],
+	mathbfup: [N.MathFont, Q.BOLD],
+	mathit: [N.MathFont, Q.MATHITALIC],
+	mathbfit: [N.MathFont, Q.BOLDITALIC],
+	mathbb: [N.MathFont, Q.DOUBLESTRUCK],
+	mathfrak: [N.MathFont, Q.FRAKTUR],
+	mathbffrak: [N.MathFont, Q.BOLDFRAKTUR],
+	mathscr: [N.MathFont, Q.SCRIPT],
+	mathbfscr: [N.MathFont, Q.BOLDSCRIPT],
+	mathsf: [N.MathFont, Q.SANSSERIF],
+	mathsfup: [N.MathFont, Q.SANSSERIF],
+	mathbfsf: [N.MathFont, Q.BOLDSANSSERIF],
+	mathbfsfup: [N.MathFont, Q.BOLDSANSSERIF],
+	mathsfit: [N.MathFont, Q.SANSSERIFITALIC],
+	mathbfsfit: [N.MathFont, Q.SANSSERIFBOLDITALIC],
+	mathtt: [N.MathFont, Q.MONOSPACE],
+	mathcal: [N.MathFont, Q.CALLIGRAPHIC],
+	mathbfcal: [N.MathFont, Q.BOLDCALLIGRAPHIC],
+	symrm: [N.MathFont, Q.NORMAL],
+	symup: [N.MathFont, Q.NORMAL],
+	symnormal: [N.MathFont, ""],
+	symbf: [
+		N.MathFont,
+		Q.BOLD,
+		Q.BOLDITALIC
+	],
+	symbfup: [N.MathFont, Q.BOLD],
+	symit: [N.MathFont, Q.ITALIC],
+	symbfit: [N.MathFont, Q.BOLDITALIC],
+	symbb: [N.MathFont, Q.DOUBLESTRUCK],
+	symfrak: [N.MathFont, Q.FRAKTUR],
+	symbffrak: [N.MathFont, Q.BOLDFRAKTUR],
+	symscr: [N.MathFont, Q.SCRIPT],
+	symbfscr: [N.MathFont, Q.BOLDSCRIPT],
+	symsf: [
+		N.MathFont,
+		Q.SANSSERIF,
+		Q.SANSSERIFITALIC
+	],
+	symsfup: [N.MathFont, Q.SANSSERIF],
+	symbfsf: [N.MathFont, Q.BOLDSANSSERIF],
+	symbfsfup: [N.MathFont, Q.BOLDSANSSERIF],
+	symsfit: [N.MathFont, Q.SANSSERIFITALIC],
+	symbfsfit: [N.MathFont, Q.SANSSERIFBOLDITALIC],
+	symtt: [N.MathFont, Q.MONOSPACE],
+	symcal: [N.MathFont, Q.CALLIGRAPHIC],
+	symbfcal: [N.MathFont, Q.BOLDCALLIGRAPHIC],
+	textrm: [
+		N.HBox,
+		null,
+		Q.NORMAL
+	],
+	textup: [
+		N.HBox,
+		null,
+		Q.NORMAL
+	],
+	textnormal: [N.HBox],
+	textit: [
+		N.HBox,
+		null,
+		Q.ITALIC
+	],
+	textbf: [
+		N.HBox,
+		null,
+		Q.BOLD
+	],
+	textsf: [
+		N.HBox,
+		null,
+		Q.SANSSERIF
+	],
+	texttt: [
+		N.HBox,
+		null,
+		Q.MONOSPACE
+	],
+	Tiny: [N.SetSize, .5],
+	tiny: [N.SetSize, .6],
+	scriptsize: [N.SetSize, .7],
+	SMALL: [N.SetSize, .7],
+	Small: [N.SetSize, .8],
+	footnotesize: [N.SetSize, .8],
+	small: [N.SetSize, .9],
+	normalsize: [N.SetSize, 1],
+	large: [N.SetSize, 1.095],
+	Large: [N.SetSize, 1.2],
+	LARGE: [N.SetSize, 1.44],
+	huge: [N.SetSize, 1.728],
+	Huge: [N.SetSize, 2.074],
+	HUGE: [N.SetSize, 2.49],
+	arcsin: N.NamedFn,
+	arccos: N.NamedFn,
+	arctan: N.NamedFn,
+	arg: N.NamedFn,
+	cos: N.NamedFn,
+	cosh: N.NamedFn,
+	cot: N.NamedFn,
+	coth: N.NamedFn,
+	csc: N.NamedFn,
+	deg: N.NamedFn,
+	det: N.NamedOp,
+	dim: N.NamedFn,
+	exp: N.NamedFn,
+	gcd: N.NamedOp,
+	hom: N.NamedFn,
+	inf: N.NamedOp,
+	ker: N.NamedFn,
+	lg: N.NamedFn,
+	lim: N.NamedOp,
+	liminf: [N.NamedOp, "lim&thinsp;inf"],
+	limsup: [N.NamedOp, "lim&thinsp;sup"],
+	ln: N.NamedFn,
+	log: N.NamedFn,
+	max: N.NamedOp,
+	min: N.NamedOp,
+	Pr: N.NamedOp,
+	sec: N.NamedFn,
+	sin: N.NamedFn,
+	sinh: N.NamedFn,
+	sup: N.NamedOp,
+	tan: N.NamedFn,
+	tanh: N.NamedFn,
+	limits: [N.Limits, !0],
+	nolimits: [N.Limits, !1],
+	overline: [N.UnderOver, "2015"],
+	underline: [N.UnderOver, "2015"],
+	overbrace: [
+		N.UnderOver,
+		"23DE",
+		!0
+	],
+	underbrace: [
+		N.UnderOver,
+		"23DF",
+		!0
+	],
+	overparen: [N.UnderOver, "23DC"],
+	underparen: [N.UnderOver, "23DD"],
+	overrightarrow: [N.UnderOver, "2192"],
+	underrightarrow: [N.UnderOver, "2192"],
+	overleftarrow: [N.UnderOver, "2190"],
+	underleftarrow: [N.UnderOver, "2190"],
+	overleftrightarrow: [N.UnderOver, "2194"],
+	underleftrightarrow: [N.UnderOver, "2194"],
+	overset: N.Overset,
+	underset: N.Underset,
+	overunderset: N.Overunderset,
+	stackrel: [
+		N.Macro,
+		"\\mathrel{\\mathop{#2}\\limits^{#1}}",
+		2
+	],
+	stackbin: [
+		N.Macro,
+		"\\mathbin{\\mathop{#2}\\limits^{#1}}",
+		2
+	],
+	over: N.Over,
+	overwithdelims: N.Over,
+	atop: N.Over,
+	atopwithdelims: N.Over,
+	above: N.Over,
+	abovewithdelims: N.Over,
+	brace: [
+		N.Over,
+		"{",
+		"}"
+	],
+	brack: [
+		N.Over,
+		"[",
+		"]"
+	],
+	choose: [
+		N.Over,
+		"(",
+		")"
+	],
+	frac: N.Frac,
+	sqrt: N.Sqrt,
+	root: N.Root,
+	uproot: [N.MoveRoot, "upRoot"],
+	leftroot: [N.MoveRoot, "leftRoot"],
+	left: N.LeftRight,
+	right: N.LeftRight,
+	middle: N.LeftRight,
+	llap: N.Lap,
+	rlap: N.Lap,
+	raise: N.RaiseLower,
+	lower: N.RaiseLower,
+	moveleft: N.MoveLeftRight,
+	moveright: N.MoveLeftRight,
+	",": [N.Spacer, W.thinmathspace],
+	":": [N.Spacer, W.mediummathspace],
+	">": [N.Spacer, W.mediummathspace],
+	";": [N.Spacer, W.thickmathspace],
+	"!": [N.Spacer, W.negativethinmathspace],
+	enspace: [N.Spacer, .5],
+	quad: [N.Spacer, 1],
+	qquad: [N.Spacer, 2],
+	thinspace: [N.Spacer, W.thinmathspace],
+	negthinspace: [N.Spacer, W.negativethinmathspace],
+	"*": N.DiscretionaryTimes,
+	allowbreak: N.AllowBreak,
+	goodbreak: [N.Linebreak, b.LineBreak.GOODBREAK],
+	badbreak: [N.Linebreak, b.LineBreak.BADBREAK],
+	nobreak: [N.Linebreak, b.LineBreak.NOBREAK],
+	break: N.Break,
+	hskip: N.Hskip,
+	hspace: N.Hskip,
+	kern: [N.Hskip, !0],
+	mskip: N.Hskip,
+	mspace: N.Hskip,
+	mkern: [N.Hskip, !0],
+	rule: N.rule,
+	Rule: [N.Rule],
+	Space: [N.Rule, "blank"],
+	nonscript: N.Nonscript,
+	big: [
+		N.MakeBig,
+		o.ORD,
+		.85
+	],
+	Big: [
+		N.MakeBig,
+		o.ORD,
+		1.15
+	],
+	bigg: [
+		N.MakeBig,
+		o.ORD,
+		1.45
+	],
+	Bigg: [
+		N.MakeBig,
+		o.ORD,
+		1.75
+	],
+	bigl: [
+		N.MakeBig,
+		o.OPEN,
+		.85
+	],
+	Bigl: [
+		N.MakeBig,
+		o.OPEN,
+		1.15
+	],
+	biggl: [
+		N.MakeBig,
+		o.OPEN,
+		1.45
+	],
+	Biggl: [
+		N.MakeBig,
+		o.OPEN,
+		1.75
+	],
+	bigr: [
+		N.MakeBig,
+		o.CLOSE,
+		.85
+	],
+	Bigr: [
+		N.MakeBig,
+		o.CLOSE,
+		1.15
+	],
+	biggr: [
+		N.MakeBig,
+		o.CLOSE,
+		1.45
+	],
+	Biggr: [
+		N.MakeBig,
+		o.CLOSE,
+		1.75
+	],
+	bigm: [
+		N.MakeBig,
+		o.REL,
+		.85
+	],
+	Bigm: [
+		N.MakeBig,
+		o.REL,
+		1.15
+	],
+	biggm: [
+		N.MakeBig,
+		o.REL,
+		1.45
+	],
+	Biggm: [
+		N.MakeBig,
+		o.REL,
+		1.75
+	],
+	mathord: [N.TeXAtom, o.ORD],
+	mathop: [N.TeXAtom, o.OP],
+	mathopen: [N.TeXAtom, o.OPEN],
+	mathclose: [N.TeXAtom, o.CLOSE],
+	mathbin: [N.TeXAtom, o.BIN],
+	mathrel: [N.TeXAtom, o.REL],
+	mathpunct: [N.TeXAtom, o.PUNCT],
+	mathinner: [N.TeXAtom, o.INNER],
+	vtop: [N.VBox, "top"],
+	vcenter: [N.VBox, "center"],
+	vbox: [N.VBox, "bottom"],
+	hsize: N.Hsize,
+	parbox: N.ParBox,
+	breakAlign: N.BreakAlign,
+	buildrel: N.BuildRel,
+	hbox: [N.HBox, 0],
+	text: N.HBox,
+	mbox: [N.HBox, 0],
+	fbox: N.FBox,
+	boxed: [
+		N.Macro,
+		"\\fbox{$\\displaystyle{#1}$}",
+		1
+	],
+	framebox: N.FrameBox,
+	makebox: N.MakeBox,
+	strut: N.Strut,
+	mathstrut: [N.Macro, "\\vphantom{(}"],
+	phantom: N.Phantom,
+	vphantom: [
+		N.Phantom,
+		1,
+		0
+	],
+	hphantom: [
+		N.Phantom,
+		0,
+		1
+	],
+	smash: N.Smash,
+	acute: [N.Accent, "00B4"],
+	grave: [N.Accent, "0060"],
+	ddot: [N.Accent, "00A8"],
+	dddot: [N.Accent, "20DB"],
+	ddddot: [N.Accent, "20DC"],
+	tilde: [N.Accent, "007E"],
+	bar: [N.Accent, "00AF"],
+	breve: [N.Accent, "02D8"],
+	check: [N.Accent, "02C7"],
+	hat: [N.Accent, "005E"],
+	vec: [
+		N.Accent,
+		"2192",
+		!1
+	],
+	dot: [N.Accent, "02D9"],
+	widetilde: [
+		N.Accent,
+		"007E",
+		!0
+	],
+	widehat: [
+		N.Accent,
+		"005E",
+		!0
+	],
+	matrix: N.Matrix,
+	array: N.Matrix,
+	pmatrix: [
+		N.Matrix,
+		"(",
+		")"
+	],
+	cases: [
+		N.Matrix,
+		"{",
+		"",
+		"left left",
+		null,
+		".2em",
+		null,
+		!0
+	],
+	eqalign: [
+		N.Matrix,
+		null,
+		null,
+		"right left",
+		Z,
+		".5em",
+		"D"
+	],
+	displaylines: [
+		N.Matrix,
+		null,
+		null,
+		"center",
+		null,
+		".5em",
+		"D"
+	],
+	cr: N.Cr,
+	"\\": N.CrLaTeX,
+	newline: [N.CrLaTeX, !0],
+	hline: N.HLine,
+	hdashline: [N.HLine, "dashed"],
+	eqalignno: [
+		N.Matrix,
+		null,
+		null,
+		"right left",
+		Z,
+		".5em",
+		"D",
+		null,
+		"right"
+	],
+	leqalignno: [
+		N.Matrix,
+		null,
+		null,
+		"right left",
+		Z,
+		".5em",
+		"D",
+		null,
+		"left"
+	],
+	hfill: N.HFill,
+	hfil: N.HFill,
+	hfilll: N.HFill,
+	bmod: [N.Macro, `\\mmlToken{mo}[lspace="${Z}" rspace="${Z}"]{mod}`],
+	pmod: [
+		N.Macro,
+		"\\pod{\\mmlToken{mi}{mod}\\kern 6mu #1}",
+		1
+	],
+	mod: [
+		N.Macro,
+		"\\mathchoice{\\kern18mu}{\\kern12mu}{\\kern12mu}{\\kern12mu}\\mmlToken{mi}{mod}\\,\\,#1",
+		1
+	],
+	pod: [
+		N.Macro,
+		"\\mathchoice{\\kern18mu}{\\kern8mu}{\\kern8mu}{\\kern8mu}(#1)",
+		1
+	],
+	iff: [N.Macro, "\\;\\Longleftrightarrow\\;"],
+	skew: [
+		N.Macro,
+		"{{#2{#3\\mkern#1mu}\\mkern-#1mu}{}}",
+		3
+	],
+	pmb: [
+		N.Macro,
+		"\\rlap{#1}\\kern1px{#1}",
+		1
+	],
+	TeX: [N.Macro, "T\\kern-.14em\\lower.5ex{E}\\kern-.115em X"],
+	LaTeX: [N.Macro, "L\\kern-.325em\\raise.21em{\\scriptstyle{A}}\\kern-.17em\\TeX"],
+	not: N.Not,
+	dots: N.Dots,
+	space: N.Tilde,
+	"\xA0": N.Tilde,
+	" ": N.Tilde,
+	begin: N.BeginEnd,
+	end: N.BeginEnd,
+	label: N.HandleLabel,
+	ref: N.HandleRef,
+	nonumber: N.HandleNoTag,
+	newcolumntype: N.NewColumnType,
+	mathchoice: N.MathChoice,
+	mmlToken: N.MmlToken
+}), new le("environment", R.environment, {
+	displaymath: [
+		N.Equation,
+		null,
+		!1
+	],
+	math: [
+		N.Equation,
+		null,
+		!1,
+		!1
+	],
+	array: [N.AlignedArray],
+	darray: [
+		N.AlignedArray,
+		null,
+		"D"
+	],
+	equation: [
+		N.Equation,
+		null,
+		!0
+	],
+	eqnarray: [
+		N.EqnArray,
+		null,
+		!0,
+		!0,
+		"rcl",
+		"bmt",
+		_.cols(0, W.thickmathspace),
+		".5em"
+	],
+	indentalign: [N.IndentAlign]
+}), new m("not_remap", null, {
+	"←": "↚",
+	"→": "↛",
+	"↔": "↮",
+	"⇐": "⇍",
+	"⇒": "⇏",
+	"⇔": "⇎",
+	"∈": "∉",
+	"∋": "∌",
+	"∣": "∤",
+	"∥": "∦",
+	"∼": "≁",
+	"~": "≁",
+	"≃": "≄",
+	"≅": "≇",
+	"≈": "≉",
+	"≍": "≭",
+	"=": "≠",
+	"≡": "≢",
+	"<": "≮",
+	">": "≯",
+	"≤": "≰",
+	"≥": "≱",
+	"≲": "≴",
+	"≳": "≵",
+	"≶": "≸",
+	"≷": "≹",
+	"≺": "⊀",
+	"≻": "⊁",
+	"⊂": "⊄",
+	"⊃": "⊅",
+	"⊆": "⊈",
+	"⊇": "⊉",
+	"⊢": "⊬",
+	"⊨": "⊭",
+	"⊩": "⊮",
+	"⊫": "⊯",
+	"≼": "⋠",
+	"≽": "⋡",
+	"⊑": "⋢",
+	"⊒": "⋣",
+	"⊲": "⋪",
+	"⊳": "⋫",
+	"⊴": "⋬",
+	"⊵": "⋭",
+	"∃": "∄"
+});
+//#endregion
+//#region node_modules/@mathjax/src/mjs/input/tex/base/BaseConfiguration.js
+var we = b.Variant;
+new m("remap", null, {
+	"-": "−",
+	"*": "∗",
+	"`": "‘"
+});
+function Te(e, t) {
+	let n = e.stack.env.font, r = e.stack.env.italicFont, i = n ? { mathvariant: n } : {}, a = ue.getMap("remap").lookup(t), o = s(t), c = o[3], l = e.create("token", c, i, a ? a.char : t), u = _.isLatinOrGreekChar(t) ? e.configuration.mathStyle(t, !0) || r : "", d = o[4] || (n && u === we.NORMAL ? "" : u);
+	d && l.attributes.set("mathvariant", d), c === "mo" && (h.setProperty(l, "fixStretchy", !0), e.configuration.addNode("fixStretchy", l)), e.Push(l);
+}
+function Ee(e, t) {
+	throw new I("UndefinedControlSequence", "Undefined control sequence %1", "\\" + t);
+}
+function De(e, t) {
+	throw new I("UnknownEnv", "Unknown environment '%1'", t);
+}
+function Oe({ data: e }) {
+	for (let t of e.getList("nonscript")) if (t.attributes.get("scriptlevel") > 0) {
+		let n = t.parent;
+		if (n.childNodes.splice(n.childIndex(t), 1), e.removeFromList(t.kind, [t]), t.isKind("mrow")) {
+			let n = t.childNodes[0];
+			e.removeFromList("mstyle", [n]), e.removeFromList("mspace", n.childNodes[0].childNodes);
+		}
+	} else t.isKind("mrow") && (t.parent.replaceChild(t.childNodes[0], t), e.removeFromList("mrow", [t]));
+}
+var ke = class extends ae {};
+ee.create("base", {
+	[y.CONFIG]: function(e, t) {
+		let n = t.parseOptions.options;
+		n.digits && (n.numberPattern = n.digits), new U("digit", R.digit, n.initialDigit), new U("letter", R.variable, n.initialLetter), e.handlers.get(v.CHARACTER).add(["letter", "digit"], null, 4);
+	},
+	[y.HANDLER]: {
+		[v.CHARACTER]: ["command", "special"],
+		[v.DELIMITER]: ["delimiter"],
+		[v.MACRO]: [
+			"delimiter",
+			"macros",
+			"lcGreek",
+			"ucGreek",
+			"mathchar0mi",
+			"mathchar0mo",
+			"mathchar7"
+		],
+		[v.ENVIRONMENT]: ["environment"]
+	},
+	[y.FALLBACK]: {
+		[v.CHARACTER]: Te,
+		[v.MACRO]: Ee,
+		[v.ENVIRONMENT]: De
+	},
+	[y.ITEMS]: {
+		[f.prototype.kind]: f,
+		[ne.prototype.kind]: ne,
+		[V.prototype.kind]: V,
+		[w.prototype.kind]: w,
+		[C.prototype.kind]: C,
+		[he.prototype.kind]: he,
+		[A.prototype.kind]: A,
+		[fe.prototype.kind]: fe,
+		[M.prototype.kind]: M,
+		[O.prototype.kind]: O,
+		[pe.prototype.kind]: pe,
+		[P.prototype.kind]: P,
+		[S.prototype.kind]: S,
+		[z.prototype.kind]: z,
+		[p.prototype.kind]: p,
+		[te.prototype.kind]: te,
+		[L.prototype.kind]: L,
+		[D.prototype.kind]: D,
+		[F.prototype.kind]: F,
+		[H.prototype.kind]: H,
+		[B.prototype.kind]: B,
+		[j.prototype.kind]: j,
+		[k.prototype.kind]: k,
+		[T.prototype.kind]: T,
+		[E.prototype.kind]: E,
+		[x.prototype.kind]: x
+	},
+	[y.OPTIONS]: {
+		maxMacros: 1e3,
+		digits: "",
+		numberPattern: /^(?:[0-9]+(?:\{,\}[0-9]{3})*(?:\.[0-9]*)?|\.[0-9]+)/,
+		initialDigit: /[0-9.,]/,
+		identifierPattern: /^[a-zA-Z]+/,
+		initialLetter: /[a-zA-Z]/,
+		baseURL: !i.document || i.document.getElementsByTagName("base").length === 0 ? "" : String(i.document.location).replace(/#.*$/, "")
+	},
+	[y.TAGS]: { base: ke },
+	[y.POSTPROCESSORS]: [[Oe, -4]]
+});
+//#endregion
+//#region node_modules/@mathjax/src/mjs/input/tex.js
+var $ = class n extends l {
+	static configure(e) {
+		let t = new me(e, ["tex"]);
+		return t.init(), t;
+	}
+	static tags(e, t) {
+		g.addTags(t.tags), g.setDefault(e.options.tags), e.tags = g.getDefault(), e.tags.configuration = e;
+	}
+	constructor(r = {}) {
+		let [i, a, o] = e(r, n.OPTIONS, K.OPTIONS);
+		super(a), this.findTeX = this.options.FindTeX || new K(o);
+		let s = this.options.packages, c = this.configuration = n.configure(s), l = this._parseOptions = new Ce(c, [this.options, g.OPTIONS]);
+		t(l.options, i), c.config(this), n.tags(l, c), this.postFilters.addList([
+			[J.cleanSubSup, -7],
+			[J.setInherited, -6],
+			[J.checkScriptlevel, -5],
+			[J.moveLimits, -4],
+			[J.cleanStretchy, -3],
+			[J.cleanAttributes, -2],
+			[J.combineRelations, -1]
+		]);
+	}
+	setMmlFactory(e) {
+		super.setMmlFactory(e), this._parseOptions.nodeFactory.setMmlFactory(e);
+	}
+	get parseOptions() {
+		return this._parseOptions;
+	}
+	reset(e = 0) {
+		this.parseOptions.tags.reset(e);
+	}
+	compile(e, t) {
+		this.parseOptions.clear(), this.parseOptions.mathItem = e, this.executeFilters(this.preFilters, e, t, this.parseOptions), this.latex = e.math;
+		let n;
+		this.parseOptions.tags.startEquation(e);
+		let r;
+		try {
+			r = new ie(this.latex, {
+				display: e.display,
+				isInner: !1
+			}, this.parseOptions), n = r.mml();
+		} catch (e) {
+			if (!(e instanceof I)) throw e;
+			this.parseOptions.error = !0, n = this.options.formatError(this, e);
+		}
+		return n = this.parseOptions.nodeFactory.create("node", "math", [n]), n.attributes.set(b.Attr.LATEX, this.latex), e.display && h.setAttribute(n, "display", "block"), this.parseOptions.tags.finishEquation(e), this.parseOptions.root = n, this.executeFilters(this.postFilters, e, t, this.parseOptions), r && r.stack.env.hsize && (h.setAttribute(n, "maxwidth", r.stack.env.hsize), h.setAttribute(n, "overflow", "linebreak")), this.mathNode = this.parseOptions.root, this.mathNode;
+	}
+	findMath(e) {
+		return this.findTeX.findMath(e);
+	}
+	formatError(e) {
+		let t = e.message.replace(/\n.*/, "");
+		return this.parseOptions.nodeFactory.create("error", t, e.id, this.latex);
+	}
+};
+$.NAME = "TeX", $.OPTIONS = Object.assign(Object.assign({}, l.OPTIONS), {
+	FindTeX: null,
+	packages: ["base"],
+	maxBuffer: 5 * 1024,
+	maxTemplateSubtitutions: 1e4,
+	mathStyle: "TeX",
+	formatError: (e, t) => e.formatError(t)
+});
+//#endregion
+export { $ as TeX };