manim-web 0.3.20 → 0.3.21

package/dist/AmsConfiguration-BMyoprhk.js

@@ -0,0 +1,847 @@
+import { h as e } from "./mo-C5uLT3Z9.js";
+import { A as t, F as n, G as r, H as i, I as a, J as o, L as s, P as c, Q as l, W as u, X as d, Y as f, Z as p, d as m, i as h, n as g, q as _, r as v, t as y, z as b } from "./ParseMethods-D3_HeS1K.js";
+import { n as x } from "./lengths-D4tR1gYA.js";
+import { a as S } from "./NewcommandMethods-C_E3iLoK.js";
+import { NewcommandConfig as C } from "./NewcommandConfiguration-bJ6P1rBY.js";
+//#region node_modules/@mathjax/src/mjs/input/tex/ams/AmsItems.js
+var w = class extends h {
+	constructor(e, ...t) {
+		super(e), this.factory.configuration.tags.start("multline", !0, t[0]);
+	}
+	get kind() {
+		return "multline";
+	}
+	EndEntry() {
+		this.table.length && u.fixInitialMO(this.factory.configuration, this.nodes);
+		let e = this.getProperty("shove"), t = this.create("node", "mtd", this.nodes, e ? { columnalign: e } : {});
+		this.setProperty("shove", null), this.row.push(t), this.Clear();
+	}
+	EndRow() {
+		if (this.row.length !== 1) throw new _("MultlineRowsOneCol", "The rows within the %1 environment must have exactly one column", "multline");
+		let e = this.create("node", "mtr", this.row);
+		this.table.push(e), this.row = [];
+	}
+	EndTable() {
+		if (super.EndTable(), this.table.length) {
+			let e = this.table.length - 1, t = -1;
+			l.getAttribute(l.getChildren(this.table[0])[0], "columnalign") || l.setAttribute(l.getChildren(this.table[0])[0], "columnalign", p.Align.LEFT), l.getAttribute(l.getChildren(this.table[e])[0], "columnalign") || l.setAttribute(l.getChildren(this.table[e])[0], "columnalign", p.Align.RIGHT);
+			let n = this.factory.configuration.tags.getTag();
+			if (n) {
+				t = this.arraydef.side === p.Align.LEFT ? 0 : this.table.length - 1;
+				let e = this.table[t], r = this.create("node", "mlabeledtr", [n].concat(l.getChildren(e)));
+				l.copyAttributes(e, r), this.table[t] = r;
+			}
+		}
+		this.factory.configuration.tags.end();
+	}
+}, T = class extends m {
+	get kind() {
+		return "flalign";
+	}
+	constructor(e, t, n, r, i) {
+		super(e), this.name = t, this.numbered = n, this.padded = r, this.center = i, this.factory.configuration.tags.start(t, n, n);
+	}
+	EndEntry() {
+		super.EndEntry();
+		let e = this.getProperty("xalignat");
+		if (e && this.row.length > e) throw new _("XalignOverflow", "Extra %1 in row of %2", "&", this.name);
+	}
+	EndRow() {
+		let e, t = this.row, n = this.getProperty("xalignat");
+		for (; t.length < n;) t.push(this.create("node", "mtd"));
+		for (this.row = [], this.padded && this.row.push(this.create("node", "mtd")); e = t.shift();) this.row.push(e), e = t.shift(), e && this.row.push(e), (t.length || this.padded) && this.row.push(this.create("node", "mtd"));
+		this.row.length > this.maxrow && (this.maxrow = this.row.length), super.EndRow();
+		let r = this.table[this.table.length - 1];
+		if (this.getProperty("zeroWidthLabel") && r.isKind("mlabeledtr")) {
+			let e = l.getChildren(r)[0], t = this.factory.configuration.options.tagSide, n = Object.assign({ width: 0 }, t === "right" ? { lspace: "-1width" } : {}), i = this.create("node", "mpadded", l.getChildren(e), n);
+			e.setChildren([i]);
+		}
+	}
+	EndTable() {
+		if (super.EndTable(), this.center && this.maxrow <= 2) {
+			let e = this.arraydef;
+			delete e.width, delete this.global.indentalign;
+		}
+	}
+};
+//#endregion
+//#region node_modules/@mathjax/src/mjs/input/tex/ams/AmsMethods.js
+function E(e) {
+	if (!e || e.isInferred && e.childNodes.length === 0) return [null, null];
+	if (e.isKind("msubsup") && D(e)) return [e, null];
+	let t = l.getChildAt(e, 0);
+	return e.isInferred && t && D(t) ? (e.childNodes.splice(0, 1), [t, e]) : [null, e];
+}
+function D(e) {
+	let t = e.childNodes[0];
+	return t && t.isKind("mi") && t.getText() === "";
+}
+var O = {
+	AmsEqnArray(e, t, n, r, i, a, o, s) {
+		let c = e.GetBrackets("\\begin{" + t.getName() + "}"), l = g.EqnArray(e, t, n, r, i, a, o, s);
+		return u.setArrayAlign(l, c, e);
+	},
+	AlignAt(e, t, n, r) {
+		let i = t.getName(), a, o = "", s = "", c = [];
+		r || (a = e.GetBrackets("\\begin{" + i + "}"));
+		let l = e.GetArgument("\\begin{" + i + "}");
+		if (l.match(/[^0-9]/)) throw new _("PositiveIntegerArg", "Argument to %1 must be a positive integer", "\\begin{" + i + "}");
+		let d = parseInt(l, 10);
+		for (; d > 0;) o += "rl", s += "bt", c.push("0em 0em"), d--;
+		let f = c.join(" ");
+		if (r) return O.EqnArray(e, t, n, r, o, s, f);
+		let p = O.EqnArray(e, t, n, r, o, s, f);
+		return u.setArrayAlign(p, a, e);
+	},
+	Multline(e, t, n) {
+		u.checkEqnEnv(e), e.Push(t);
+		let r = e.options.ams.multlineIndent, i = e.itemFactory.create("multline", n, e.stack);
+		return i.arraydef = {
+			displaystyle: !0,
+			rowspacing: ".5em",
+			columnspacing: "100%",
+			width: e.options.ams.multlineWidth,
+			side: e.options.tagSide,
+			minlabelspacing: e.options.tagIndent,
+			"data-array-padding": `${r} ${r}`,
+			"data-width-includes-label": !0
+		}, i;
+	},
+	XalignAt(e, t, n, r) {
+		let i = e.GetArgument("\\begin{" + t.getName() + "}");
+		if (i.match(/[^0-9]/)) throw new _("PositiveIntegerArg", "Argument to %1 must be a positive integer", "\\begin{" + t.getName() + "}");
+		let a = r ? "crl" : "rlc", o = r ? "mbt" : "btm", s = r ? "fit auto auto" : "auto auto fit", c = O.FlalignArray(e, t, n, r, !1, a, o, s, !0);
+		return c.setProperty("xalignat", 2 * parseInt(i)), c;
+	},
+	FlalignArray(e, t, n, r, i, a, o, s, c = !1) {
+		u.checkEqnEnv(e), e.Push(t), a = a.split("").join(" ").replace(/r/g, "right").replace(/l/g, "left").replace(/c/g, "center"), o = v(o);
+		let l = e.itemFactory.create("flalign", t.getName(), n, r, i, e.stack);
+		return l.arraydef = {
+			width: "100%",
+			displaystyle: !0,
+			columnalign: a,
+			columnspacing: "0em",
+			columnwidth: s,
+			rowspacing: "3pt",
+			"data-break-align": o,
+			side: e.options.tagSide,
+			minlabelspacing: c ? "0" : e.options.tagIndent,
+			"data-width-includes-label": !0
+		}, l.setProperty("zeroWidthLabel", c), l;
+	},
+	HandleDeclareOp(e, t) {
+		let n = e.GetStar() ? "*" : "", r = S.GetCsNameArgument(e, t), i = e.GetArgument(t);
+		S.addMacro(e, r, O.Macro, [`\\operatorname${n}{${i}}`]), e.Push(e.itemFactory.create("null"));
+	},
+	HandleOperatorName(t, n) {
+		let i = t.GetStar(), a = new r(o.trimSpaces(t.GetArgument(n)), Object.assign(Object.assign({}, t.stack.env), {
+			font: p.Variant.NORMAL,
+			multiLetterIdentifiers: t.options.ams.operatornamePattern,
+			operatorLetters: !0,
+			noAutoOP: !0
+		}), t.configuration).mml();
+		if (a.isKind("mi") ? a.removeProperty("autoOP") : a = t.create("node", "TeXAtom", [a]), l.setProperties(a, {
+			movesupsub: i,
+			movablelimits: !0,
+			texClass: e.OP
+		}), !i) {
+			let e = t.GetNext(), n = t.i;
+			e === "\\" && ++t.i && t.GetCS() !== "limits" && (t.i = n);
+		}
+		t.Push(t.itemFactory.create("fn", a));
+	},
+	SideSet(t, n) {
+		let [r, i] = E(t.ParseArg(n)), [a, o] = E(t.ParseArg(n)), s = t.ParseArg(n), c = s;
+		r && (i ? r.replaceChild(t.create("node", "mphantom", [t.create("node", "mpadded", [u.copyNode(s, t)], { width: 0 })]), l.getChildAt(r, 0)) : (c = t.create("node", "mmultiscripts", [s]), a && l.appendChildren(c, [l.getChildAt(a, 1) || t.create("node", "none"), l.getChildAt(a, 2) || t.create("node", "none")]), l.setProperty(c, "scriptalign", "left"), l.appendChildren(c, [
+			t.create("node", "mprescripts"),
+			l.getChildAt(r, 1) || t.create("node", "none"),
+			l.getChildAt(r, 2) || t.create("node", "none")
+		]))), a && c === s && (a.replaceChild(s, l.getChildAt(a, 0)), c = a);
+		let d = t.create("node", "TeXAtom", [], {
+			texClass: e.OP,
+			movesupsub: !0,
+			movablelimits: !0
+		});
+		i && (r && d.appendChild(r), d.appendChild(i)), d.appendChild(c), o && d.appendChild(o), t.Push(d);
+	},
+	operatorLetter(e, t) {
+		return e.stack.env.operatorLetters ? y.variable(e, t) : !1;
+	},
+	MultiIntegral(e, t, n) {
+		let r = e.GetNext();
+		if (r === "\\") {
+			let i = e.i;
+			r = e.GetArgument(t), e.i = i, r === "\\limits" && (n = "\\!\\!\\mathop{\\,\\," + n + "}");
+		}
+		e.string = n + " " + e.string.slice(e.i), e.i = 0;
+	},
+	xArrow(t, n, i, a, s, c = 0) {
+		let u = {
+			width: "+" + o.em((a + s) / 18),
+			lspace: o.em(a / 18)
+		}, d = t.GetBrackets(n), f = t.ParseArg(n), p = t.create("node", "mspace", [], { depth: ".2em" }), m = t.create("token", "mo", {
+			stretchy: !0,
+			texClass: e.ORD
+		}, String.fromCodePoint(i));
+		c && m.attributes.set("minsize", o.em(c)), m = t.create("node", "mstyle", [m], { scriptlevel: 0 });
+		let h = t.create("node", "munderover", [m]), g = t.create("node", "mpadded", [f, p], u);
+		if (l.setAttribute(g, "voffset", "-.2em"), l.setAttribute(g, "height", "-.2em"), l.setChild(h, h.over, g), d) {
+			let e = new r(d, t.stack.env, t.configuration).mml(), n = t.create("node", "mspace", [], { height: ".75em" });
+			g = t.create("node", "mpadded", [e, n], u), l.setAttribute(g, "voffset", ".15em"), l.setAttribute(g, "depth", "-.15em"), l.setChild(h, h.under, g);
+		}
+		l.setProperty(h, "subsupOK", !0), t.Push(t.create("node", "TeXAtom", [t.create("node", "TeXAtom", [], { texClass: e.NONE }), h], { texClass: e.REL }));
+	},
+	HandleShove(e, t, n) {
+		let r = e.stack.Top();
+		if (r.kind !== "multline") throw new _("CommandOnlyAllowedInEnv", "%1 only allowed in %2 environment", e.currentCS, "multline");
+		if (r.Size()) throw new _("CommandAtTheBeginingOfLine", "%1 must come at the beginning of the line", e.currentCS);
+		r.setProperty("shove", n);
+	},
+	CFrac(e, t) {
+		let n = o.trimSpaces(e.GetBrackets(t, "")), i = e.GetArgument(t), a = e.GetArgument(t), s = {
+			l: p.Align.LEFT,
+			r: p.Align.RIGHT,
+			"": ""
+		}, c = new r("\\strut\\textstyle{" + i + "}", e.stack.env, e.configuration).mml(), u = new r("\\strut\\textstyle{" + a + "}", e.stack.env, e.configuration).mml(), d = e.create("node", "mfrac", [c, u]);
+		if (n = s[n], n == null) throw new _("IllegalAlign", "Illegal alignment specified in %1", e.currentCS);
+		n && l.setProperties(d, {
+			numalign: n,
+			denomalign: n
+		}), e.Push(d);
+	},
+	Genfrac(e, t, n, r, i, a) {
+		n ??= e.GetDelimiterArg(t), r ??= e.GetDelimiterArg(t), i ??= e.GetArgument(t), a ??= o.trimSpaces(e.GetArgument(t));
+		let s = e.ParseArg(t), c = e.ParseArg(t), d = e.create("node", "mfrac", [s, c]);
+		if (i !== "" && l.setAttribute(d, "linethickness", i), (n || r) && (l.setProperty(d, "withDelims", !0), d = u.fixedFence(e.configuration, n, d, r)), a !== "") {
+			let t = parseInt(a, 10), n = [
+				"D",
+				"T",
+				"S",
+				"SS"
+			][t];
+			if (n == null) throw new _("BadMathStyleFor", "Bad math style for %1", e.currentCS);
+			d = e.create("node", "mstyle", [d]), n === "D" ? l.setProperties(d, {
+				displaystyle: !0,
+				scriptlevel: 0
+			}) : l.setProperties(d, {
+				displaystyle: !1,
+				scriptlevel: t - 1
+			});
+		}
+		e.Push(d);
+	},
+	HandleTag(e, t) {
+		if (!e.tags.currentTag.taggable && e.tags.env) throw new _("CommandNotAllowedInEnv", "%1 not allowed in %2 environment", e.currentCS, e.tags.env);
+		if (e.tags.currentTag.tag) throw new _("MultipleCommand", "Multiple %1", e.currentCS);
+		let n = e.GetStar(), r = o.trimSpaces(e.GetArgument(t));
+		e.tags.tag(r, n), e.Push(e.itemFactory.create("null"));
+	},
+	HandleNoTag: g.HandleNoTag,
+	HandleRef: g.HandleRef,
+	Macro: g.Macro,
+	Accent: g.Accent,
+	Tilde: g.Tilde,
+	Array: g.Array,
+	Spacer: g.Spacer,
+	NamedOp: g.NamedOp,
+	EqnArray: g.EqnArray,
+	Equation: g.Equation
+};
+new c("AMSmath-mathchar0mo", y.mathchar0mo, { iiiint: ["⨌", { texClass: e.OP }] }), new b("AMSmath-operatorLetter", O.operatorLetter, /[-*]/i), new n("AMSmath-macros", {
+	mathring: [O.Accent, "02DA"],
+	nobreakspace: O.Tilde,
+	negmedspace: [O.Spacer, x.negativemediummathspace],
+	negthickspace: [O.Spacer, x.negativethickmathspace],
+	idotsint: [O.MultiIntegral, "\\int\\cdots\\int"],
+	dddot: [O.Accent, "20DB"],
+	ddddot: [O.Accent, "20DC"],
+	sideset: O.SideSet,
+	boxed: [
+		O.Macro,
+		"\\fbox{$\\displaystyle{#1}$}",
+		1
+	],
+	tag: O.HandleTag,
+	notag: O.HandleNoTag,
+	eqref: [O.HandleRef, !0],
+	substack: [
+		O.Macro,
+		"\\begin{subarray}{c}#1\\end{subarray}",
+		1
+	],
+	injlim: [O.NamedOp, "inj&thinsp;lim"],
+	projlim: [O.NamedOp, "proj&thinsp;lim"],
+	varliminf: [O.Macro, "\\mathop{\\underline{\\mmlToken{mi}{lim}}}"],
+	varlimsup: [O.Macro, "\\mathop{\\overline{\\mmlToken{mi}{lim}}}"],
+	varinjlim: [O.Macro, "\\mathop{\\underrightarrow{\\mmlToken{mi}{lim}}}"],
+	varprojlim: [O.Macro, "\\mathop{\\underleftarrow{\\mmlToken{mi}{lim}}}"],
+	DeclareMathOperator: O.HandleDeclareOp,
+	operatorname: O.HandleOperatorName,
+	genfrac: O.Genfrac,
+	frac: [
+		O.Genfrac,
+		"",
+		"",
+		"",
+		""
+	],
+	tfrac: [
+		O.Genfrac,
+		"",
+		"",
+		"",
+		"1"
+	],
+	dfrac: [
+		O.Genfrac,
+		"",
+		"",
+		"",
+		"0"
+	],
+	binom: [
+		O.Genfrac,
+		"(",
+		")",
+		"0",
+		""
+	],
+	tbinom: [
+		O.Genfrac,
+		"(",
+		")",
+		"0",
+		"1"
+	],
+	dbinom: [
+		O.Genfrac,
+		"(",
+		")",
+		"0",
+		"0"
+	],
+	cfrac: O.CFrac,
+	shoveleft: [O.HandleShove, p.Align.LEFT],
+	shoveright: [O.HandleShove, p.Align.RIGHT],
+	xrightarrow: [
+		O.xArrow,
+		8594,
+		5,
+		10
+	],
+	xleftarrow: [
+		O.xArrow,
+		8592,
+		10,
+		5
+	]
+}), new s("AMSmath-environment", y.environment, {
+	"equation*": [
+		O.Equation,
+		null,
+		!1
+	],
+	"eqnarray*": [
+		O.EqnArray,
+		null,
+		!1,
+		!0,
+		"rcl",
+		"bmt",
+		u.cols(0, x.thickmathspace),
+		".5em"
+	],
+	align: [
+		O.EqnArray,
+		null,
+		!0,
+		!0,
+		"rl",
+		"bt",
+		u.cols(0, 2)
+	],
+	"align*": [
+		O.EqnArray,
+		null,
+		!1,
+		!0,
+		"rl",
+		"bt",
+		u.cols(0, 2)
+	],
+	multline: [
+		O.Multline,
+		null,
+		!0
+	],
+	"multline*": [
+		O.Multline,
+		null,
+		!1
+	],
+	split: [
+		O.EqnArray,
+		null,
+		!1,
+		!1,
+		"rl",
+		"bt",
+		u.cols(0)
+	],
+	gather: [
+		O.EqnArray,
+		null,
+		!0,
+		!0,
+		"c",
+		"m"
+	],
+	"gather*": [
+		O.EqnArray,
+		null,
+		!1,
+		!0,
+		"c",
+		"m"
+	],
+	alignat: [
+		O.AlignAt,
+		null,
+		!0,
+		!0
+	],
+	"alignat*": [
+		O.AlignAt,
+		null,
+		!1,
+		!0
+	],
+	alignedat: [
+		O.AlignAt,
+		null,
+		!1,
+		!1
+	],
+	aligned: [
+		O.AmsEqnArray,
+		null,
+		null,
+		null,
+		"rl",
+		"bt",
+		u.cols(0, 2),
+		".5em",
+		"D"
+	],
+	gathered: [
+		O.AmsEqnArray,
+		null,
+		null,
+		null,
+		"c",
+		"m",
+		null,
+		".5em",
+		"D"
+	],
+	xalignat: [
+		O.XalignAt,
+		null,
+		!0,
+		!0
+	],
+	"xalignat*": [
+		O.XalignAt,
+		null,
+		!1,
+		!0
+	],
+	xxalignat: [
+		O.XalignAt,
+		null,
+		!1,
+		!1
+	],
+	flalign: [
+		O.FlalignArray,
+		null,
+		!0,
+		!1,
+		!0,
+		"rlc",
+		"btm",
+		"auto auto fit"
+	],
+	"flalign*": [
+		O.FlalignArray,
+		null,
+		!1,
+		!1,
+		!0,
+		"rlc",
+		"btm",
+		"auto auto fit"
+	],
+	subarray: [
+		O.Array,
+		null,
+		null,
+		null,
+		null,
+		u.cols(0),
+		"0.1em",
+		"S",
+		!0
+	],
+	smallmatrix: [
+		O.Array,
+		null,
+		null,
+		null,
+		"c",
+		u.cols(1 / 3),
+		".2em",
+		"S",
+		!0
+	],
+	matrix: [
+		O.Array,
+		null,
+		null,
+		null,
+		"c"
+	],
+	pmatrix: [
+		O.Array,
+		null,
+		"(",
+		")",
+		"c"
+	],
+	bmatrix: [
+		O.Array,
+		null,
+		"[",
+		"]",
+		"c"
+	],
+	Bmatrix: [
+		O.Array,
+		null,
+		"\\{",
+		"\\}",
+		"c"
+	],
+	vmatrix: [
+		O.Array,
+		null,
+		"\\vert",
+		"\\vert",
+		"c"
+	],
+	Vmatrix: [
+		O.Array,
+		null,
+		"\\Vert",
+		"\\Vert",
+		"c"
+	],
+	cases: [
+		O.Array,
+		null,
+		"\\{",
+		".",
+		"ll",
+		null,
+		".2em",
+		"T"
+	]
+}), new a("AMSmath-delimiter", y.delimiter, {
+	"\\lvert": ["|", { texClass: e.OPEN }],
+	"\\rvert": ["|", { texClass: e.CLOSE }],
+	"\\lVert": ["‖", { texClass: e.OPEN }],
+	"\\rVert": ["‖", { texClass: e.CLOSE }]
+}), new c("AMSsymbols-mathchar0mi", y.mathchar0mi, {
+	digamma: "ϝ",
+	varkappa: "ϰ",
+	varGamma: ["Γ", { mathvariant: p.Variant.ITALIC }],
+	varDelta: ["Δ", { mathvariant: p.Variant.ITALIC }],
+	varTheta: ["Θ", { mathvariant: p.Variant.ITALIC }],
+	varLambda: ["Λ", { mathvariant: p.Variant.ITALIC }],
+	varXi: ["Ξ", { mathvariant: p.Variant.ITALIC }],
+	varPi: ["Π", { mathvariant: p.Variant.ITALIC }],
+	varSigma: ["Σ", { mathvariant: p.Variant.ITALIC }],
+	varUpsilon: ["Υ", { mathvariant: p.Variant.ITALIC }],
+	varPhi: ["Φ", { mathvariant: p.Variant.ITALIC }],
+	varPsi: ["Ψ", { mathvariant: p.Variant.ITALIC }],
+	varOmega: ["Ω", { mathvariant: p.Variant.ITALIC }],
+	beth: "ℶ",
+	gimel: "ℷ",
+	daleth: "ℸ",
+	backprime: ["‵", { variantForm: !0 }],
+	hslash: "ℏ",
+	varnothing: ["∅", { variantForm: !0 }],
+	blacktriangle: "▴",
+	triangledown: ["▽", { variantForm: !0 }],
+	blacktriangledown: "▾",
+	square: "◻",
+	Box: "◻",
+	blacksquare: "◼",
+	lozenge: "◊",
+	Diamond: "◊",
+	blacklozenge: "⧫",
+	circledS: ["Ⓢ", { mathvariant: p.Variant.NORMAL }],
+	bigstar: "★",
+	sphericalangle: "∢",
+	measuredangle: "∡",
+	nexists: "∄",
+	complement: "∁",
+	mho: "℧",
+	eth: ["ð", { mathvariant: p.Variant.NORMAL }],
+	Finv: "Ⅎ",
+	diagup: "╱",
+	Game: "⅁",
+	diagdown: "╲",
+	Bbbk: ["k", { mathvariant: p.Variant.DOUBLESTRUCK }],
+	yen: "¥",
+	circledR: "®",
+	checkmark: "✓",
+	maltese: "✠"
+}), new c("AMSsymbols-mathchar0mo", y.mathchar0mo, {
+	dotplus: "∔",
+	ltimes: "⋉",
+	smallsetminus: ["∖", { variantForm: !0 }],
+	rtimes: "⋊",
+	Cap: "⋒",
+	doublecap: "⋒",
+	leftthreetimes: "⋋",
+	Cup: "⋓",
+	doublecup: "⋓",
+	rightthreetimes: "⋌",
+	barwedge: "⊼",
+	curlywedge: "⋏",
+	veebar: "⊻",
+	curlyvee: "⋎",
+	doublebarwedge: "⩞",
+	boxminus: "⊟",
+	circleddash: "⊝",
+	boxtimes: "⊠",
+	circledast: "⊛",
+	boxdot: "⊡",
+	circledcirc: "⊚",
+	boxplus: "⊞",
+	centerdot: ["⋅", { variantForm: !0 }],
+	divideontimes: "⋇",
+	intercal: "⊺",
+	leqq: "≦",
+	geqq: "≧",
+	leqslant: "⩽",
+	geqslant: "⩾",
+	eqslantless: "⪕",
+	eqslantgtr: "⪖",
+	lesssim: "≲",
+	gtrsim: "≳",
+	lessapprox: "⪅",
+	gtrapprox: "⪆",
+	approxeq: "≊",
+	lessdot: "⋖",
+	gtrdot: "⋗",
+	lll: "⋘",
+	llless: "⋘",
+	ggg: "⋙",
+	gggtr: "⋙",
+	lessgtr: "≶",
+	gtrless: "≷",
+	lesseqgtr: "⋚",
+	gtreqless: "⋛",
+	lesseqqgtr: "⪋",
+	gtreqqless: "⪌",
+	doteqdot: "≑",
+	Doteq: "≑",
+	eqcirc: "≖",
+	risingdotseq: "≓",
+	circeq: "≗",
+	fallingdotseq: "≒",
+	triangleq: "≜",
+	backsim: "∽",
+	thicksim: ["∼", { variantForm: !0 }],
+	backsimeq: "⋍",
+	thickapprox: ["≈", { variantForm: !0 }],
+	subseteqq: "⫅",
+	supseteqq: "⫆",
+	Subset: "⋐",
+	Supset: "⋑",
+	sqsubset: "⊏",
+	sqsupset: "⊐",
+	preccurlyeq: "≼",
+	succcurlyeq: "≽",
+	curlyeqprec: "⋞",
+	curlyeqsucc: "⋟",
+	precsim: "≾",
+	succsim: "≿",
+	precapprox: "⪷",
+	succapprox: "⪸",
+	vartriangleleft: "⊲",
+	lhd: "⊲",
+	vartriangleright: "⊳",
+	rhd: "⊳",
+	trianglelefteq: "⊴",
+	unlhd: "⊴",
+	trianglerighteq: "⊵",
+	unrhd: "⊵",
+	vDash: "⊨",
+	Vdash: "⊩",
+	Vvdash: "⊪",
+	smallsmile: ["⌣", { variantForm: !0 }],
+	shortmid: ["∣", { variantForm: !0 }],
+	smallfrown: ["⌢", { variantForm: !0 }],
+	shortparallel: ["∥", { variantForm: !0 }],
+	bumpeq: "≏",
+	between: "≬",
+	Bumpeq: "≎",
+	pitchfork: "⋔",
+	varpropto: ["∝", { variantForm: !0 }],
+	backepsilon: "∍",
+	blacktriangleleft: "◂",
+	blacktriangleright: "▸",
+	therefore: "∴",
+	because: "∵",
+	eqsim: "≂",
+	vartriangle: ["△", { variantForm: !0 }],
+	Join: "⋈",
+	nless: "≮",
+	ngtr: "≯",
+	nleq: "≰",
+	ngeq: "≱",
+	nleqslant: ["⪇", { variantForm: !0 }],
+	ngeqslant: ["⪈", { variantForm: !0 }],
+	nleqq: ["≰", { variantForm: !0 }],
+	ngeqq: ["≱", { variantForm: !0 }],
+	lneq: "⪇",
+	gneq: "⪈",
+	lneqq: "≨",
+	gneqq: "≩",
+	lvertneqq: ["≨", { variantForm: !0 }],
+	gvertneqq: ["≩", { variantForm: !0 }],
+	lnsim: "⋦",
+	gnsim: "⋧",
+	lnapprox: "⪉",
+	gnapprox: "⪊",
+	nprec: "⊀",
+	nsucc: "⊁",
+	npreceq: ["⋠", { variantForm: !0 }],
+	nsucceq: ["⋡", { variantForm: !0 }],
+	precneqq: "⪵",
+	succneqq: "⪶",
+	precnsim: "⋨",
+	succnsim: "⋩",
+	precnapprox: "⪹",
+	succnapprox: "⪺",
+	nsim: "≁",
+	ncong: "≇",
+	nshortmid: ["∤", { variantForm: !0 }],
+	nshortparallel: ["∦", { variantForm: !0 }],
+	nmid: "∤",
+	nparallel: "∦",
+	nvdash: "⊬",
+	nvDash: "⊭",
+	nVdash: "⊮",
+	nVDash: "⊯",
+	ntriangleleft: "⋪",
+	ntriangleright: "⋫",
+	ntrianglelefteq: "⋬",
+	ntrianglerighteq: "⋭",
+	nsubseteq: "⊈",
+	nsupseteq: "⊉",
+	nsubseteqq: ["⊈", { variantForm: !0 }],
+	nsupseteqq: ["⊉", { variantForm: !0 }],
+	subsetneq: "⊊",
+	supsetneq: "⊋",
+	varsubsetneq: ["⊊", { variantForm: !0 }],
+	varsupsetneq: ["⊋", { variantForm: !0 }],
+	subsetneqq: "⫋",
+	supsetneqq: "⫌",
+	varsubsetneqq: ["⫋", { variantForm: !0 }],
+	varsupsetneqq: ["⫌", { variantForm: !0 }],
+	leftleftarrows: "⇇",
+	rightrightarrows: "⇉",
+	leftrightarrows: "⇆",
+	rightleftarrows: "⇄",
+	Lleftarrow: "⇚",
+	Rrightarrow: "⇛",
+	twoheadleftarrow: "↞",
+	twoheadrightarrow: "↠",
+	leftarrowtail: "↢",
+	rightarrowtail: "↣",
+	looparrowleft: "↫",
+	looparrowright: "↬",
+	leftrightharpoons: "⇋",
+	rightleftharpoons: ["⇌", { variantForm: !0 }],
+	curvearrowleft: "↶",
+	curvearrowright: "↷",
+	circlearrowleft: "↺",
+	circlearrowright: "↻",
+	Lsh: "↰",
+	Rsh: "↱",
+	upuparrows: "⇈",
+	downdownarrows: "⇊",
+	upharpoonleft: "↿",
+	upharpoonright: "↾",
+	downharpoonleft: "⇃",
+	restriction: "↾",
+	multimap: "⊸",
+	downharpoonright: "⇂",
+	leftrightsquigarrow: "↭",
+	rightsquigarrow: "⇝",
+	leadsto: "⇝",
+	dashrightarrow: "⇢",
+	dashleftarrow: "⇠",
+	nleftarrow: "↚",
+	nrightarrow: "↛",
+	nLeftarrow: "⇍",
+	nRightarrow: "⇏",
+	nleftrightarrow: "↮",
+	nLeftrightarrow: "⇎"
+}), new a("AMSsymbols-delimiter", y.delimiter, {
+	"\\ulcorner": "⌜",
+	"\\urcorner": "⌝",
+	"\\llcorner": "⌞",
+	"\\lrcorner": "⌟"
+}), new n("AMSsymbols-macros", {
+	implies: [O.Macro, "\\;\\Longrightarrow\\;"],
+	impliedby: [O.Macro, "\\;\\Longleftarrow\\;"]
+});
+//#endregion
+//#region node_modules/@mathjax/src/mjs/input/tex/ams/AmsConfiguration.js
+var k = class extends i {};
+t.create("ams", {
+	[f.HANDLER]: {
+		[d.CHARACTER]: ["AMSmath-operatorLetter"],
+		[d.DELIMITER]: ["AMSsymbols-delimiter", "AMSmath-delimiter"],
+		[d.MACRO]: [
+			"AMSsymbols-mathchar0mi",
+			"AMSsymbols-mathchar0mo",
+			"AMSsymbols-delimiter",
+			"AMSsymbols-macros",
+			"AMSmath-mathchar0mo",
+			"AMSmath-macros",
+			"AMSmath-delimiter"
+		],
+		[d.ENVIRONMENT]: ["AMSmath-environment"]
+	},
+	[f.ITEMS]: {
+		[w.prototype.kind]: w,
+		[T.prototype.kind]: T
+	},
+	[f.TAGS]: { ams: k },
+	[f.OPTIONS]: {
+		multlineWidth: "",
+		ams: {
+			operatornamePattern: /^[-*a-zA-Z0-9]+/,
+			multlineWidth: "100%",
+			multlineIndent: "1em"
+		}
+	},
+	[f.CONFIG]: C
+});
+//#endregion