@pie-framework/math-validation 1.4.2 → 2.0.0-next.20261110063142

package/dist/index.js

@@ -0,0 +1,1594 @@
+import e from "debug";
+import { all as t, create as n } from "mathjs";
+// src/conversion/error.ts
+var r = class extends Error {
+	location;
+	constructor(e, t) {
+		super(e || "Error parsing input"), this.name = "ParseError", this.location = t;
+	}
+}, i = () => {}, a = (t) => typeof process < "u" && process.env.NODE_ENV === "test" ? e(t) : i, o = a("mv:lexer"), s = class {
+	input;
+	location;
+	rules;
+	whitespace;
+	constructor(e, t = "\\s") {
+		this.input = "", this.location = 0, this.whitespace = RegExp(`^(${t})+`), this.rules = e.map((e) => {
+			let [t, n, r] = e, i = [RegExp(`^${t}`), n];
+			return r && i.push(r), i;
+		});
+	}
+	set_input(e) {
+		if (typeof e != "string") throw Error("Input must be a string");
+		this.input = e, this.location = 0;
+	}
+	return_state() {
+		return {
+			input: this.input,
+			location: this.location
+		};
+	}
+	set_state({ input: e = null, location: t = 0 } = {}) {
+		e !== null && (this.input = e, this.location = t);
+	}
+	advance({ remove_initial_space: e = !0 } = {}) {
+		o("[advance] input: ", this.input);
+		let t = this.whitespace.exec(this.input), n = this.input.match(this.whitespace);
+		if (o("input:", this.input, "result:", t, n), o("ws result:", t), t) {
+			let n = t[0].length;
+			if (this.input = this.input.slice(n), this.location += n, o("location:", this.location, "input now:", this.input), !e) return {
+				token_type: "SPACE",
+				token_text: t[0],
+				original_text: t[0]
+			};
+		}
+		if (this.input.length === 0) return {
+			token_type: "EOF",
+			token_text: "",
+			original_text: ""
+		};
+		t = null;
+		for (var r of this.rules) if (t = r[0].exec(this.input), t) {
+			let e = t[0].length;
+			this.input = this.input.slice(e), this.location += e;
+			break;
+		}
+		return t === null ? {
+			token_type: "INVALID",
+			token_text: this.input[0],
+			original_text: this.input[0]
+		} : r.length > 2 ? {
+			token_type: r[1],
+			token_text: r[2],
+			original_text: t[0]
+		} : {
+			token_type: r[1],
+			token_text: t[0],
+			original_text: t[0]
+		};
+	}
+	unput(e) {
+		if (typeof e != "string") throw Error("Input must be a string");
+		this.location -= e.length, this.input = e + this.input;
+	}
+}, c = (e) => {
+	if (e != null) return e.tree === void 0 ? e : e.tree;
+}, l = {
+	"+": !0,
+	"*": !0,
+	and: !0,
+	or: !0,
+	union: !0,
+	intersect: !0
+};
+function u(e) {
+	var t = c(e);
+	if (!Array.isArray(t)) return t;
+	var n = t[0], r = t.slice(1);
+	if (r = r.map((e) => u(e)), l[n]) {
+		let e = [];
+		for (let t = 0; t < r.length; t++) Array.isArray(r[t]) && r[t][0] === n ? e = e.concat(r[t].slice(1)) : e.push(r[t]);
+		r = e;
+	}
+	return [n].concat(r);
+}
+// src/conversion/latex-to-ast.ts
+var d = "\\s|\\\\,|\\\\!|\\\\ |\\\\>|\\\\;|\\\\:|\\\\quad\\b|\\\\qquad\\b", f = "(E[+\\-]?[0-9]+\\s*($|(?=\\,|&|\\||\\\\\\||\\)|\\}|\\\\}|\\]|\\\\\\\\|\\\\end)))?", p = [
+	["(mm|cm|km|ft|yd|mi|mmi|li|rd|angstrom|mil|mL|ml|L|m3|in3|ft3|pt|qt|gal|bbl){1}", "UNIT"],
+	["\\$", "TEXT"],
+	["\\\\\\$", "TEXT"],
+	["\\\\text{[a-zA-Z0-9\\s\\\\,\\\\.]+?}", "TEXT"],
+	["[0-9]+\\s*\\\\frac(?![a-zA-Z])", "MIXED_NUMBER"],
+	["[0-9]{1,3}(\\,[0-9]{3})+(\\.[0-9]+)*" + f, "NUMBER"],
+	["[0-9]+(\\.[0-9]*)?" + f, "NUMBER"],
+	["\\.[0-9]+" + f, "NUMBER"],
+	[",", ","],
+	["\\*", "*"],
+	["\\×", "*"],
+	["\\•", "*"],
+	["\\·", "*"],
+	["\\/", "/"],
+	["\\÷", "/"],
+	["%", "PERCENT"],
+	["\\\\%", "PERCENT"],
+	["−", "-"],
+	["-", "-"],
+	["\\+", "+"],
+	["\\^", "^"],
+	["\\(", "("],
+	["\\\\left\\s*\\(", "("],
+	["\\\\bigl\\s*\\(", "("],
+	["\\\\Bigl\\s*\\(", "("],
+	["\\\\biggl\\s*\\(", "("],
+	["\\\\Biggl\\s*\\(", "("],
+	["\\)", ")"],
+	["\\\\right\\s*\\)", ")"],
+	["\\\\bigr\\s*\\)", ")"],
+	["\\\\Bigr\\s*\\)", ")"],
+	["\\\\biggr\\s*\\)", ")"],
+	["\\\\Biggr\\s*\\)", ")"],
+	["\\[", "["],
+	["\\\\left\\s*\\[", "["],
+	["\\\\bigl\\s*\\[", "["],
+	["\\\\Bigl\\s*\\[", "["],
+	["\\\\biggl\\s*\\[", "["],
+	["\\\\Biggl\\s*\\[", "["],
+	["\\]", "]"],
+	["\\\\right\\s*\\]", "]"],
+	["\\\\bigr\\s*\\]", "]"],
+	["\\\\Bigr\\s*\\]", "]"],
+	["\\\\biggr\\s*\\]", "]"],
+	["\\\\Biggr\\s*\\]", "]"],
+	["\\|", "|"],
+	["\\\\left\\s*\\|", "|L"],
+	["\\\\bigl\\s*\\|", "|L"],
+	["\\\\Bigl\\s*\\|", "|L"],
+	["\\\\biggl\\s*\\|", "|L"],
+	["\\\\Biggl\\s*\\|", "|L"],
+	["\\\\right\\s*\\|", "|"],
+	["\\\\bigr\\s*\\|", "|"],
+	["\\\\Bigr\\s*\\|", "|"],
+	["\\\\biggr\\s*\\|", "|"],
+	["\\\\Biggr\\s*\\|", "|"],
+	["\\\\big\\s*\\|", "|"],
+	["\\\\Big\\s*\\|", "|"],
+	["\\\\bigg\\s*\\|", "|"],
+	["\\\\Bigg\\s*\\|", "|"],
+	["{", "{"],
+	["}", "}"],
+	["\\\\{", "LBRACE"],
+	["\\\\left\\s*\\\\{", "LBRACE"],
+	["\\\\bigl\\s*\\\\{", "LBRACE"],
+	["\\\\Bigl\\s*\\\\{", "LBRACE"],
+	["\\\\biggl\\s*\\\\{", "LBRACE"],
+	["\\\\Biggl\\s*\\\\{", "LBRACE"],
+	["\\\\}", "RBRACE"],
+	["\\\\right\\s*\\\\}", "RBRACE"],
+	["\\\\bigr\\s*\\\\}", "RBRACE"],
+	["\\\\Bigr\\s*\\\\}", "RBRACE"],
+	["\\\\biggr\\s*\\\\}", "RBRACE"],
+	["\\\\Biggr\\s*\\\\}", "RBRACE"],
+	["\\\\cdot(?![a-zA-Z])", "*"],
+	["\\\\div(?![a-zA-Z])", "/"],
+	["\\\\times(?![a-zA-Z])", "*"],
+	["\\\\frac(?![a-zA-Z])", "FRAC"],
+	["°", "deg"],
+	["°", "deg"],
+	["\\\\degree", "deg"],
+	["\\\\deg", "deg"],
+	["\\\\grade", "grad"],
+	["\\\\gon", "grad"],
+	["\\\\grad", "grad"],
+	[":", ":"],
+	["\\\\mid", "MID"],
+	[
+		"\\\\vartheta(?![a-zA-Z])",
+		"LATEXCOMMAND",
+		"\\theta"
+	],
+	[
+		"\\\\π",
+		"LATEXCOMMAND",
+		"\\pi"
+	],
+	[
+		"\\\\varepsilon(?![a-zA-Z])",
+		"LATEXCOMMAND",
+		"\\epsilon"
+	],
+	[
+		"\\\\varrho(?![a-zA-Z])",
+		"LATEXCOMMAND",
+		"\\rho"
+	],
+	[
+		"\\\\varphi(?![a-zA-Z])",
+		"LATEXCOMMAND",
+		"\\phi"
+	],
+	["\\\\infty(?![a-zA-Z])", "INFINITY"],
+	["\\\\Infinity(?![a-zA-Z])", "INFINITY"],
+	["\\\\sqrt(?![a-zA-Z])", "SQRT"],
+	["\\\\log(?![a-zA-Z])", "LOG"],
+	["\\\\ln(?![a-zA-Z])", "LN"],
+	[
+		"\\\\cosec",
+		"LATEXCOMMAND",
+		"\\csc"
+	],
+	[
+		"\\\\sin\\^\\{-1}(?![a-zA-Z])",
+		"LATEXCOMMAND",
+		"\\asin"
+	],
+	[
+		"\\\\cos\\^\\{-1}(?![a-zA-Z])",
+		"LATEXCOMMAND",
+		"\\acos"
+	],
+	[
+		"\\\\tan\\^\\{-1}(?![a-zA-Z])",
+		"LATEXCOMMAND",
+		"\\atan"
+	],
+	[
+		"\\\\cot\\^\\{-1}(?![a-zA-Z])",
+		"LATEXCOMMAND",
+		"\\acot"
+	],
+	[
+		"\\\\sec\\^\\{-1}(?![a-zA-Z])",
+		"LATEXCOMMAND",
+		"\\asec"
+	],
+	[
+		"\\\\csc\\^\\{-1}(?![a-zA-Z])",
+		"LATEXCOMMAND",
+		"\\acsc"
+	],
+	[
+		"\\\\arsin(?![a-zA-Z])",
+		"LATEXCOMMAND",
+		"\\asin"
+	],
+	[
+		"\\\\arcsin(?![a-zA-Z])",
+		"LATEXCOMMAND",
+		"\\asin"
+	],
+	[
+		"\\\\arcos(?![a-zA-Z])",
+		"LATEXCOMMAND",
+		"\\acos"
+	],
+	[
+		"\\\\arccos(?![a-zA-Z])",
+		"LATEXCOMMAND",
+		"\\acos"
+	],
+	[
+		"\\\\artan(?![a-zA-Z])",
+		"LATEXCOMMAND",
+		"\\atan"
+	],
+	[
+		"\\\\arctan(?![a-zA-Z])",
+		"LATEXCOMMAND",
+		"\\atan"
+	],
+	[
+		"\\\\arcot(?![a-zA-Z])",
+		"LATEXCOMMAND",
+		"\\acot"
+	],
+	[
+		"\\\\arccot(?![a-zA-Z])",
+		"LATEXCOMMAND",
+		"\\acot"
+	],
+	[
+		"\\\\arsec(?![a-zA-Z])",
+		"LATEXCOMMAND",
+		"\\asec"
+	],
+	[
+		"\\\\arcsec(?![a-zA-Z])",
+		"LATEXCOMMAND",
+		"\\asec"
+	],
+	[
+		"\\\\arcsc(?![a-zA-Z])",
+		"LATEXCOMMAND",
+		"\\acsc"
+	],
+	[
+		"\\\\arccsc(?![a-zA-Z])",
+		"LATEXCOMMAND",
+		"\\acsc"
+	],
+	["\\\\land(?![a-zA-Z])", "AND"],
+	["\\\\wedge(?![a-zA-Z])", "AND"],
+	["\\\\lor(?![a-zA-Z])", "OR"],
+	["\\\\vee(?![a-zA-Z])", "OR"],
+	["\\\\lnot(?![a-zA-Z])", "NOT"],
+	["=", "="],
+	["≠", "NE"],
+	["\\\\neq(?![a-zA-Z])", "NE"],
+	["\\\\ne(?![a-zA-Z])", "NE"],
+	["\\\\not\\s*=", "NE"],
+	["\\\\leq(?![a-zA-Z])", "LE"],
+	["\\\\le(?![a-zA-Z])", "LE"],
+	["\\\\geq(?![a-zA-Z])", "GE"],
+	["\\\\ge(?![a-zA-Z])", "GE"],
+	["<", "<"],
+	["≤", "LE"],
+	["\\\\lt(?![a-zA-Z])", "<"],
+	[">", ">"],
+	["≥", "GE"],
+	["\\\\gt(?![a-zA-Z])", ">"],
+	["\\\\approx", "≈"],
+	["≈", "≈"],
+	["\\\\napprox", "≉"],
+	["≉", "≉"],
+	["\\\\simeq", "≃"],
+	["≃", "≃"],
+	["\\\\sim", "~"],
+	["~", "~"],
+	["\\\\nsim", "≁"],
+	["≁", "≁"],
+	["\\\\cong", "≅"],
+	["≅", "≅"],
+	["\\\\ncong", "≆"],
+	["≆", "≆"],
+	["f\\^\\{-1}", "TEXT"],
+	["g\\^\\{-1}", "TEXT"],
+	["\\\\in(?![a-zA-Z])", "IN"],
+	["\\\\notin(?![a-zA-Z])", "NOTIN"],
+	["\\\\not\\s*\\\\in(?![a-zA-Z])", "NOTIN"],
+	["\\\\ni(?![a-zA-Z])", "NI"],
+	["\\\\not\\s*\\\\ni(?![a-zA-Z])", "NOTNI"],
+	["\\\\subset(?![a-zA-Z])", "SUBSET"],
+	["\\\\not\\s*\\\\subset(?![a-zA-Z])", "NOTSUBSET"],
+	["\\\\supset(?![a-zA-Z])", "SUPERSET"],
+	["\\\\not\\s*\\\\supset(?![a-zA-Z])", "NOTSUPERSET"],
+	["\\\\cup(?![a-zA-Z])", "UNION"],
+	["\\\\cap(?![a-zA-Z])", "INTERSECT"],
+	["!", "!"],
+	["'", "'"],
+	["_", "_"],
+	["&", "&"],
+	["\\\\ldots", "LDOTS"],
+	["\\\\\\\\", "LINEBREAK"],
+	["\\\\begin\\s*{\\s*[a-zA-Z0-9]+\\s*}", "BEGINENVIRONMENT"],
+	["\\\\end\\s*{\\s*[a-zA-Z0-9]+\\s*}", "ENDENVIRONMENT"],
+	["\\\\var\\s*{\\s*[a-zA-Z0-9]+\\s*}", "VARMULTICHAR"],
+	["\\\\[a-zA-Z]+(?![a-zA-Z])", "LATEXCOMMAND"],
+	["[a-zA-Z]", "VAR"]
+], ee = {
+	allowSimplifiedFunctionApplication: !0,
+	allowedLatexSymbols: /* @__PURE__ */ "alpha.beta.gamma.Gamma.delta.Delta.epsilon.zeta.eta.theta.Theta.iota.kappa.lambda.Lambda.mu.nu.xi.Xi.pi.Pi.rho.sigma.Sigma.tau.Tau.upsilon.Upsilon.phi.Phi.chi.psi.Psi.omega.Omega.partial".split("."),
+	appliedFunctionSymbols: /* @__PURE__ */ "abs.exp.log.ln.log10.sign.sqrt.erf.acos.acosh.acot.acoth.acsc.acsch.asec.asech.asin.asinh.atan.atanh.cos.cosh.cot.coth.csc.csch.sec.sech.sin.sinh.tan.tanh.arg".split("."),
+	functionSymbols: ["f", "g"],
+	parseLeibnizNotation: !0,
+	missingFactor: (e, t) => {
+		throw t;
+	},
+	unknownCommandBehavior: "passthrough",
+	keepMixedNumbers: !1
+}, m = class {
+	lexer;
+	token;
+	opts;
+	constructor(e) {
+		if (this.opts = {
+			...ee,
+			...e
+		}, this.opts.unknownCommandBehavior !== "error" && this.opts.unknownCommandBehavior !== "passthrough") throw Error("Unknown behavior for unknown command: " + this.opts.unknownCommandBehavior);
+		this.lexer = new s(p, d);
+	}
+	advance(e) {
+		if (this.token = this.lexer.advance(e), this.token.token_type === "INVALID") throw new r("Invalid symbol '" + this.token.original_text + "'", this.lexer.location);
+	}
+	return_state() {
+		return {
+			lexer_state: this.lexer.return_state(),
+			token: Object.assign({}, this.token)
+		};
+	}
+	set_state(e) {
+		this.lexer.set_state(e.lexer_state), this.token = Object.assign({}, e.token);
+	}
+	convert(e, t) {
+		this.lexer.set_input(e), this.advance();
+		var n = this.statement_list(t);
+		if (this.token.token_type !== "EOF") throw new r("Invalid location of '" + this.token.original_text + "'", this.lexer.location);
+		return u(n);
+	}
+	statement_list(e) {
+		for (var t = [this.statement(e)]; this.token.token_type === ",";) this.advance(), t.push(this.statement(e));
+		return t = t.length > 1 ? ["list"].concat(t) : t[0], t;
+	}
+	statement(e = {}) {
+		let { inside_absolute_value: t = 0, unknownCommands: n = "error" } = e;
+		if (this.token.token_type === "LDOTS") return this.advance(), ["ldots"];
+		var r;
+		try {
+			r = this.return_state();
+			let e = this.statement_a({
+				inside_absolute_value: t,
+				unknownCommands: n
+			});
+			if (this.token.token_type !== ":" && this.token.token_type !== "MID") return e;
+			let i = this.token.token_type === ":" ? ":" : "|";
+			return this.advance(), [
+				i,
+				e,
+				this.statement_a({ unknownCommands: n })
+			];
+		} catch (e) {
+			try {
+				this.set_state(r);
+				let t = this.statement_a({ parse_absolute_value: !1 });
+				if (this.token.token_type[0] !== "|") throw e;
+				return this.advance(), [
+					"|",
+					t,
+					this.statement_a({ parse_absolute_value: !1 })
+				];
+			} catch {
+				throw e;
+			}
+		}
+	}
+	statement_a(e = {}) {
+		let { inside_absolute_value: t = 0, parse_absolute_value: n = !0, unknownCommands: r } = e;
+		for (var i = this.statement_b({
+			inside_absolute_value: t,
+			parse_absolute_value: n,
+			unknownCommands: r
+		}); this.token.token_type === "OR";) {
+			let e = this.token.token_type.toLowerCase();
+			this.advance();
+			let a = this.statement_b({
+				inside_absolute_value: t,
+				parse_absolute_value: n,
+				unknownCommands: r
+			});
+			i = [
+				e,
+				i,
+				a
+			];
+		}
+		return i;
+	}
+	statement_b(e) {
+		for (var t = this.relation(e); this.token.token_type === "AND";) {
+			let n = this.token.token_type.toLowerCase();
+			this.advance();
+			let r = this.relation(e);
+			t = [
+				n,
+				t,
+				r
+			];
+		}
+		return t;
+	}
+	relation(e) {
+		if (this.token.token_type === "NOT" || this.token.token_type === "!") return this.advance(), ["not", this.relation(e)];
+		var t = this.expression(e);
+		let n = (e) => e === "<" || e === "LE" || e === ">" || e === "GE" || e === "NE";
+		for (; this.token.token_type === "=" || this.token.token_type === "NE" || this.token.token_type === "<" || this.token.token_type === ">" || this.token.token_type === "LE" || this.token.token_type === "GE" || this.token.token_type === "IN" || this.token.token_type === "NOTIN" || this.token.token_type === "NI" || this.token.token_type === "NOTNI" || this.token.token_type === "SUBSET" || this.token.token_type === "NOTSUBSET" || this.token.token_type === "SUPERSET" || this.token.token_type === "NOTSUPERSET" || this.token.token_type === "≈" || this.token.token_type === "≉" || this.token.token_type === "~" || this.token.token_type === "≃" || this.token.token_type === "≁" || this.token.token_type === "≅" || this.token.token_type === "≆";) {
+			let r = this.token.token_type.toLowerCase(), i = n(this.token.token_type);
+			this.advance();
+			let a = this.expression(e), o = (e) => {
+				switch (e) {
+					case "<": return "smaller";
+					case "LE":
+					case "le": return "smallerEq";
+					case ">": return "larger";
+					case "GE":
+					case "ge": return "largerEq";
+					case "NE":
+					case "ne": return "unequal";
+				}
+			};
+			if (i && n(this.token.token_type)) {
+				let i = ["tuple"];
+				i.push(o(r));
+				let s = [
+					"tuple",
+					t,
+					a
+				];
+				for (; n(this.token.token_type);) i.push(o(this.token.token_type)), this.advance(), s.push(this.expression(e));
+				t = [
+					"relational",
+					s,
+					i
+				];
+			} else if (r === "=") for (t = [
+				r,
+				t,
+				a
+			]; this.token.token_type === "=";) this.advance(), t.push(this.expression(e));
+			else t = [
+				r,
+				t,
+				a
+			];
+		}
+		return t;
+	}
+	expression(e) {
+		this.token.token_type === "+" && this.advance();
+		let t = !1;
+		this.token.token_type === "-" && (t = !0, this.advance());
+		var n = this.term(e);
+		for (t && (n = ["-", n]); this.token.token_type === "+" || this.token.token_type === "-" || this.token.token_type === "UNION" || this.token.token_type === "INTERSECT";) {
+			let t = this.token.token_type.toLowerCase(), r = !1;
+			this.token.token_type === "-" ? (t = "+", r = !0, this.advance()) : (this.advance(), t === "+" && this.token.token_type === "-" && (r = !0, this.advance()));
+			let i = this.term(e);
+			r && (i = ["-", i]), n = [
+				t,
+				n,
+				i
+			];
+		}
+		return n;
+	}
+	term(e) {
+		var t;
+		try {
+			t = this.factor(e);
+		} catch (e) {
+			t = this.opts.missingFactor(this.token, e), t = Number.isFinite(t) ? t : 0;
+		}
+		var n = !1;
+		do
+			if (n = !1, this.token.token_type === "PERCENT") this.advance(), t = ["%", t], n = !0;
+			else if (this.token.token_type === "*") this.advance(), t = [
+				"*",
+				t,
+				this.factor(e)
+			], n = !0;
+			else if (this.token.token_type === "/") this.advance(), t = [
+				"/",
+				t,
+				this.factor(e)
+			], n = !0;
+			else {
+				let r = Object.assign({}, e);
+				r.allow_absolute_value_closing = !0;
+				let i = this.nonMinusFactor(r);
+				i !== !1 && (t = [
+					"*",
+					t,
+					i
+				], n = !0);
+			}
+		while (n);
+		return t;
+	}
+	factor(e) {
+		if (this.token.token_type === "-") return this.advance(), ["-", this.factor(e)];
+		var t = this.nonMinusFactor(e);
+		if (t === !1) throw this.token.token_type === "EOF" ? new r("Unexpected end of input", this.lexer.location) : new r("Invalid location of '" + this.token.original_text + "'", this.lexer.location);
+		return t;
+	}
+	nonMinusFactor(e) {
+		let t = this.baseFactor(e);
+		if (this.token.token_type === "!" || this.token.token_type === "'") {
+			if (t === !1) throw new r("Invalid location of " + this.token.token_type, this.lexer.location);
+			for (; this.token.token_type === "!" || this.token.token_type === "'";) t = this.token.token_type === "!" ? [
+				"apply",
+				"factorial",
+				t
+			] : ["prime", t], this.advance();
+		}
+		if (this.token.token_type === "^") {
+			if (t === !1) throw new r("Invalid location of ^", this.lexer.location);
+			this.advance();
+			let n = Object.assign({}, e);
+			return delete n.allow_absolute_value_closing, delete n.inside_absolute_value, [
+				"^",
+				t,
+				this.factor(n)
+			];
+		}
+		return t;
+	}
+	fraction({ parse_absolute_value: e = !0, unknownCommands: t = "error" }) {
+		if (this.advance(), this.token.token_type !== "{") throw new r("Expecting {", this.lexer.location);
+		if (this.advance(), this.opts.parseLeibnizNotation) {
+			let e = this.return_state(), t = this.leibniz_notation();
+			if (t) return t;
+			this.set_state(e);
+		}
+		let n = this.statement({
+			parse_absolute_value: e,
+			unknownCommands: t
+		});
+		if (this.token.token_type !== "}") throw new r("Expecting }", this.lexer.location);
+		if (this.advance(), this.token.token_type !== "{") throw new r("Expecting {", this.lexer.location);
+		this.advance();
+		let i = this.statement({
+			parse_absolute_value: e,
+			unknownCommands: t
+		});
+		if (this.token.token_type !== "}") throw new r("Expecting }", this.lexer.location);
+		return this.advance(), [
+			"/",
+			n,
+			i
+		];
+	}
+	baseFactor({ inside_absolute_value: e = 0, parse_absolute_value: t = !0, allow_absolute_value_closing: n = !1, unknownCommands: i = "error" } = {}) {
+		var a = !1;
+		if (this.token.token_type === "MIXED_NUMBER") try {
+			let e = this.token.token_text.split("\\\\frac")[0].trim(), t = parseInt(e, 10), n = this.fraction({});
+			return this.opts.keepMixedNumbers ? [
+				"mixed",
+				t,
+				n
+			] : [
+				"+",
+				t,
+				n
+			];
+		} catch (e) {
+			throw new r(`Mixed number parsing failed: ${e.message}`);
+		}
+		if (this.token.token_type === "FRAC") return this.fraction({});
+		if (this.token.token_type === "TEXT") {
+			let e = this.token.original_text.replace(/[[\]\\]/g, "");
+			return this.advance(), e.toString();
+		}
+		if (this.token.token_type === "BEGINENVIRONMENT") {
+			let e = /\\begin\s*{\s*([a-zA-Z0-9]+)\s*}/.exec(this.token.token_text)[1];
+			if ([
+				"matrix",
+				"pmatrix",
+				"bmatrix"
+			].includes(e)) {
+				let n = 0, o = 0, s = [], c = [], l = 0, u = this.token.token_type;
+				for (this.advance(); this.token.token_type !== "ENDENVIRONMENT";) this.token.token_type === "&" ? ((u === "&" || u === "LINEBREAK") && (c.push(0), l += 1), u = this.token.token_type, this.advance()) : this.token.token_type === "LINEBREAK" ? ((u === "&" || u === "LINEBREAK") && (c.push(0), l += 1), s.push(c), l > o && (o = l), n += 1, l = 0, c = [], u = this.token.token_type, this.advance()) : (c.push(this.statement({
+					parse_absolute_value: t,
+					unknownCommands: i
+				})), l += 1, u = " ");
+				if (/\\end\s*{\s*([a-zA-Z0-9]+)\s*}/.exec(this.token.token_text)[1] !== e) throw new r("Expecting \\end{" + e + "}", this.lexer.location);
+				u === "&" && (c.push(0), l += 1), s.push(c), l > o && (o = l), n += 1, this.advance(), a = ["matrix", [
+					"tuple",
+					n,
+					o
+				]];
+				let d = ["tuple"];
+				for (let e of s) {
+					let t = ["tuple"].concat(e);
+					for (let n = e.length; n < o; n += 1) t.push(0);
+					d.push(t);
+				}
+				return a.push(d), a;
+			}
+			throw new r("Unrecognized environment " + e, this.lexer.location);
+		}
+		if (this.token.token_type === "NUMBER") {
+			a = this.token.token_text.replace(/,/g, "");
+			let e = a === "0" ? a : ((e) => e.indexOf(".") >= 0 ? e.replace(/^[0]*([0-9])(.*)/, "$1$2") : e.replace(/0*([1-9]*)/, "$1"))(a);
+			e.startsWith(".") && (e = "0" + e);
+			let t = parseFloat(e);
+			if (e !== t.toString()) {
+				let n = t.toString();
+				a = [
+					"tzn",
+					t,
+					e.substring(n.length).split("").filter((e) => e === "0").length
+				];
+			} else a = t;
+			this.advance();
+		} else if (this.token.token_type === "INFINITY") a = Infinity, this.advance();
+		else if (this.token.token_type === "deg") a = ["*", Math.PI / 180], this.advance();
+		else if (this.token.token_type === "grad") a = ["*", Math.PI / 200], this.advance();
+		else if (this.token.token_type === "UNIT") a = ["unit", this.token.token_text], this.advance();
+		else if (this.token.token_type === "SQRT") {
+			this.advance();
+			let e = 2, n;
+			if (this.token.token_type === "[") {
+				if (this.advance(), n = this.statement({
+					parse_absolute_value: t,
+					unknownCommands: i
+				}), this.token.token_type !== "]") throw new r("Expecting ]", this.lexer.location);
+				this.advance(), e = n;
+			}
+			if (this.token.token_type === "{") {
+				if (this.advance(), n = this.statement({
+					parse_absolute_value: t,
+					unknownCommands: i
+				}), this.token.token_type !== "}") throw new r("Expecting }", this.lexer.location);
+				this.advance();
+			} else n = this.statement({
+				parse_absolute_value: t,
+				unknownCommands: i
+			});
+			a = e === 2 ? [
+				"apply",
+				"sqrt",
+				n
+			] : [
+				"^",
+				n,
+				[
+					"/",
+					1,
+					e
+				]
+			];
+		} else if (this.token.token_type === "LOG" || this.token.token_type === "LN") {
+			let e = this.token.token_type === "LOG" ? 10 : "e", n;
+			if (this.advance(), this.token.token_type === "_" && (this.advance(), this.token.token_type === "{")) {
+				if (this.advance(), n = this.statement({
+					parse_absolute_value: t,
+					unknownCommands: i
+				}), this.token.token_type !== "}") throw new r("Expecting }", this.lexer.location);
+				this.advance(), e = n;
+			}
+			if (this.token.token_type === "(") {
+				if (this.advance(), n = this.statement({
+					parse_absolute_value: t,
+					unknownCommands: i
+				}), this.token.token_type !== ")") throw new r("Expecting )", this.lexer.location);
+				this.advance();
+			} else n = this.token.token_text, this.advance();
+			a = e === 10 ? [
+				"apply",
+				"log",
+				[
+					"tuple",
+					n,
+					e
+				]
+			] : e === "e" ? [
+				"apply",
+				"log",
+				n
+			] : [
+				"apply",
+				"log",
+				[
+					"tuple",
+					n,
+					e
+				]
+			];
+		} else if (this.token.token_type === "VAR" || this.token.token_type === "LATEXCOMMAND" || this.token.token_type === "VARMULTICHAR") {
+			if (a = this.token.token_text, this.token.token_type === "LATEXCOMMAND") {
+				if (a = a.slice(1), !(this.opts.appliedFunctionSymbols.includes(a) || this.opts.functionSymbols.includes(a) || this.opts.allowedLatexSymbols.includes(a)) && this.opts.unknownCommandBehavior === "error") throw new r("Unrecognized latex command " + this.token.original_text, this.lexer.location);
+			} else this.token.token_type === "VARMULTICHAR" && (a = /\\var\s*\{\s*([a-zA-Z0-9]+)\s*\}/.exec(a)[1]);
+			if (this.opts.appliedFunctionSymbols.includes(a) || this.opts.functionSymbols.includes(a)) {
+				let e = !1;
+				if (this.opts.appliedFunctionSymbols.includes(a) && (e = !0), this.advance(), this.token.token_type === "_") {
+					this.advance();
+					let e = this.baseFactor({ parse_absolute_value: t });
+					if (e === !1) throw this.token.token_type === "EOF" ? new r("Unexpected end of input", this.lexer.location) : new r("Invalid location of '" + this.token.original_text + "'", this.lexer.location);
+					a = [
+						"_",
+						a,
+						e
+					];
+				}
+				for (; this.token.token_type === "'";) a = ["prime", a], this.advance();
+				if (this.token.token_type === "^" && (this.advance(), a = [
+					"^",
+					a,
+					this.factor({ parse_absolute_value: t })
+				]), this.token.token_type === "{" || this.token.token_type === "(") {
+					let e;
+					e = this.token.token_type === "{" ? "}" : ")", this.advance();
+					let t = this.statement_list();
+					if (this.token.token_type !== e) throw new r("Expecting " + e, this.lexer.location);
+					this.advance(), a = [
+						"apply",
+						a,
+						t
+					];
+				} else if (e) {
+					if (!this.opts.allowSimplifiedFunctionApplication) throw new r("Expecting ( after function", this.lexer.location);
+					a = [
+						"apply",
+						a,
+						this.factor({ parse_absolute_value: t })
+					];
+				}
+			} else this.advance();
+		} else if (this.token.token_type === "(" || this.token.token_type === "[" || this.token.token_type === "{" || this.token.token_type === "LBRACE") {
+			let e = this.token.token_type, t, n;
+			this.token.token_type === "(" ? (t = ")", n = "]") : this.token.token_type === "[" ? (t = "]", n = ")") : this.token.token_type === "{" ? (t = "}", n = null) : (t = "RBRACE", n = null), this.advance(), a = this.statement_list();
+			let i = 1;
+			if (a[0] === "list" && (i = a.length - 1), this.token.token_type !== t) {
+				if (i !== 2 || n === null) throw new r("Expecting " + t, this.lexer.location);
+				if (this.token.token_type !== n) throw new r("Expecting ) or ]", this.lexer.location);
+				a[0] = "list", a = ["interval", a];
+				let o;
+				o = e === "(" ? [
+					"list",
+					!1,
+					!0
+				] : [
+					"list",
+					!0,
+					!1
+				], a.push(o);
+			} else i >= 2 ? e === "(" || e === "{" || e === "[" ? a[0] = "list" : a[0] = "set" : e === "LBRACE" && (a = (a[0] === "|" || a[0], ["set", a]));
+			this.advance();
+		} else if (this.token.token_type[0] === "|" && t && (e === 0 || !n || this.token.token_type[1] === "L")) {
+			if (e += 1, this.advance(), a = this.statement({
+				inside_absolute_value: e,
+				unknownCommands: i
+			}), a = [
+				"apply",
+				"abs",
+				a
+			], this.token.token_type !== "|") throw new r("Expecting |", this.lexer.location);
+			this.advance();
+		}
+		if (this.token.token_type === "_") {
+			if (a === !1) throw new r("Invalid location of _", this.lexer.location);
+			this.advance();
+			let e = this.baseFactor({ parse_absolute_value: t });
+			if (e === !1) throw this.token.token_type === "EOF" ? new r("Unexpected end of input", this.lexer.location) : new r("Invalid location of '" + this.token.original_text + "'", this.lexer.location);
+			return [
+				"_",
+				a,
+				e
+			];
+		}
+		return a;
+	}
+	leibniz_notation() {
+		var e = this.token.token_text;
+		let t = "", n = 1, r = "", i = [], a = [];
+		if (this.token.token_type === "LATEXCOMMAND" && e.slice(1) === "partial") t = "∂";
+		else if (this.token.token_type === "VAR" && e === "d") t = "d";
+		else return !1;
+		if (this.advance(), this.token.token_type === "^") {
+			this.advance();
+			let e = !1;
+			if (this.token.token_type === "{" && (e = !0, this.advance()), this.token.token_type !== "NUMBER" || (n = parseFloat(this.token.token_text), !Number.isInteger(n)) || e && (this.advance(), this.token.token_type !== "}")) return !1;
+			this.advance();
+		}
+		if (this.token.token_type === "VAR") r = this.token.token_text;
+		else if (this.token.token_type === "VARMULTICHAR") r = /\\var\s*\{\s*([a-zA-Z0-9]+)\s*\}/.exec(this.token.token_text)[1];
+		else if (this.token.token_type === "LATEXCOMMAND") {
+			if (e = this.token.token_text.slice(1), this.opts.allowedLatexSymbols.includes(e)) r = e;
+			else return !1;
+		}
+		if (this.advance(), this.token.token_type !== "}" || (this.advance(), this.token.token_type !== "{")) return !1;
+		this.advance();
+		let o = 0;
+		for (;;) {
+			if (!(t === "d" && this.token.token_type === "VAR" && this.token.token_text === "d" || t === "∂" && this.token.token_type === "LATEXCOMMAND" && this.token.token_text.slice(1) === "partial")) return !1;
+			if (this.advance(), this.token.token_type === "VAR") i.push(this.token.token_text);
+			else if (this.token.token_type === "VARMULTICHAR") i.push(/\\var\s*\{\s*([a-zA-Z0-9]+)\s*\}/.exec(this.token.token_text)[1]);
+			else if (this.token.token_type === "LATEXCOMMAND") {
+				let e = this.token.token_text.slice(1);
+				if (this.allowedLatexSymbols.includes(e)) i.push(e);
+				else return !1;
+			} else return !1;
+			let s = 1;
+			if (this.advance(), this.token.token_type === "^") {
+				this.advance();
+				let e = !1;
+				if (this.token.token_type === "{" && (e = !0, this.advance()), this.token.token_type !== "NUMBER" || (s = parseFloat(this.token.token_text), !Number.isInteger(s)) || e && (this.advance(), this.token.token_type !== "}")) return !1;
+				this.advance();
+			}
+			if (a.push(s), o += s, o > n) return !1;
+			if (o === n) {
+				if (this.token.token_type !== "}") return !1;
+				this.advance();
+				let o = "derivative_leibniz";
+				t === "∂" && (o = "partial_" + o), e = [o], n === 1 ? e.push(r) : e.push([
+					"tuple",
+					r,
+					n
+				]);
+				let s = [];
+				for (let e = 0; e < i.length; e += 1) a[e] === 1 ? s.push(i[e]) : s.push([
+					"tuple",
+					i[e],
+					a[e]
+				]);
+				return s = ["tuple"].concat(s), e.push(s), e;
+			}
+		}
+	}
+}, h = n(t, { number: "Fraction" }), { parse: te } = h;
+h.replacer;
+var g = n(t), _ = Object.freeze({
+	l: "tzn(n1, n2)",
+	r: "n1"
+}), v = a("mv:ast-to-math"), y = h, b = {
+	"+": (e) => new y.OperatorNode("+", "add", e),
+	"*": (e) => {
+		let [t, n] = e;
+		if (t?.type === "ConstantNode" && n?.isUnit && typeof t.value == "object") {
+			let e = t.value.valueOf();
+			return y.multiply(e, n);
+		}
+		return new y.OperatorNode("*", "multiply", e);
+	},
+	"/": (e) => new y.OperatorNode("/", "divide", e),
+	"-": (e) => new y.OperatorNode("-", "unaryMinus", [e[0]]),
+	"^": (e) => new y.OperatorNode("^", "pow", e),
+	list: (e) => new y.ArrayNode(e),
+	vector: (e) => new y.ArrayNode(e),
+	and: (e) => new y.OperatorNode("and", "and", e),
+	or: (e) => new y.OperatorNode("or", "or", e),
+	not: (e) => new y.OperatorNode("not", "not", [e[0]]),
+	"<": (e) => new y.OperatorNode("<", "smaller", e),
+	">": (e) => new y.OperatorNode(">", "larger", e),
+	le: (e) => new y.OperatorNode("<=", "smallerEq", e),
+	ge: (e) => new y.OperatorNode(">=", "largerEq", e),
+	_: (e) => {
+		let [t, ...n] = e;
+		return new y.SymbolNode(`${t}[${n}]`);
+	},
+	ne: (e) => new y.OperatorNode("!=", "unequal", e),
+	tzn: (e) => new y.FunctionNode("tzn", e),
+	"≈": (e) => new y.FunctionNode("≈", e),
+	"≉": (e) => new y.FunctionNode("≉", e),
+	"~": (e) => new y.FunctionNode("~", e),
+	"≃": (e) => new y.FunctionNode("≃", e),
+	"≁": (e) => new y.FunctionNode("≁", e),
+	"≅": (e) => new y.FunctionNode("≅", e),
+	"≆": (e) => new y.FunctionNode("≆", e)
+}, ne = class {
+	convert(e) {
+		if (typeof e == "number") {
+			if (Number.isFinite(e)) {
+				let t = new y.Fraction([new y.ConstantNode(e), new y.ConstantNode(1)]);
+				return new y.ConstantNode(t);
+			}
+			return Number.isNaN(e) ? new y.SymbolNode("NaN") : e < 0 ? b["-"]([new y.SymbolNode("Infinity")]) : new y.SymbolNode("Infinity");
+		}
+		if (typeof e == "string") return new y.SymbolNode(e);
+		if (typeof e == "boolean") throw Error("no support for boolean");
+		if (!Array.isArray(e)) throw Error("Invalid ast");
+		let t = e[0], n = e.slice(1);
+		if (t === "apply") {
+			if (v("operands:", n), v("0", n[0]), typeof n[0] != "string") throw Error("Non string functions not implemented for conversion to mathjs");
+			if (n[0] === "factorial") return new y.OperatorNode("!", "factorial", [this.convert(n[1])]);
+			let e = n[0], t = n[1], r;
+			return r = t[0] === "tuple" ? t.slice(1).map(function(e) {
+				return this.convert(e);
+			}.bind(this)) : [this.convert(t)], new y.FunctionNode(e, r);
+		}
+		if (t === "unit") return new y.Unit(1, n[0]);
+		if (t === "relational") {
+			let e = n[0], t = n[1];
+			if (e[0] !== "tuple" || t[0] !== "tuple") throw Error("Badly formed ast");
+			e.splice(0, 1), t.splice(0, 1);
+			let r = e.map(function(e) {
+				return this.convert(e);
+			}.bind(this)), i = [];
+			for (let n = 0; n < e.length - 1; n++) i.push(t[n]);
+			return new y.RelationalNode(i, r);
+		}
+		if (t === "=") {
+			let e = n.map(function(e) {
+				return this.convert(e);
+			}.bind(this)), t = [];
+			for (let n = 0; n < e.length - 1; n++) t.push("equal");
+			return t.length === 1 ? new y.OperatorNode("==", "equal", e) : new y.RelationalNode(t, e);
+		}
+		if (t === "in" || t === "notin" || t === "ni" || t === "notni") {
+			let e, r;
+			if (t === "in" || t === "notin" ? (e = n[0], r = n[1]) : (e = n[1], r = n[0]), typeof e != "number" && typeof e != "string") throw Error("Set membership non-string variables not implemented for conversion to mathjs");
+			if (e = this.convert(e), r[0] !== "interval") throw Error("Set membership in non-intervals not implemented for conversion to mathjs");
+			let i = r[1], a = r[2];
+			if (i[0] !== "tuple" || a[0] !== "tuple") throw Error("Badly formed ast");
+			let o = this.convert(i[1]), s = this.convert(i[2]), c = [];
+			a[1] ? c.push(new y.OperatorNode(">=", "largerEq", [e, o])) : c.push(new y.OperatorNode(">", "larger", [e, o])), a[2] ? c.push(new y.OperatorNode("<=", "smallerEq", [e, s])) : c.push(new y.OperatorNode("<", "smaller", [e, s]));
+			let l = new y.OperatorNode("and", "and", c);
+			return (t === "notin" || t === "notni") && (l = new y.OperatorNode("not", "not", [l])), l;
+		}
+		if (t === "subset" || t === "notsubset" || t === "superset" || t === "notsuperset") {
+			let e, r;
+			if (t === "subset" || t === "notsubset" ? (r = n[0], e = n[1]) : (r = n[1], e = n[0]), r[0] !== "interval" || e[0] !== "interval") throw Error("Set containment of non-intervals not implemented for conversion to mathjs");
+			let i = r[1], a = r[2], o = e[1], s = e[2];
+			if (i[0] !== "tuple" || a[0] !== "tuple" || o[0] !== "tuple" || s[0] !== "tuple") throw Error("Badly formed ast");
+			let c = this.convert(i[1]), l = this.convert(i[2]), u = this.convert(o[1]), d = this.convert(o[2]), f = [];
+			a[1] && !s[1] ? f.push(new y.OperatorNode(">", "larger", [c, u])) : f.push(new y.OperatorNode(">=", "largerEq", [c, u])), a[2] && !s[2] ? f.push(new y.OperatorNode("<", "smaller", [l, d])) : f.push(new y.OperatorNode("<=", "smallerEq", [l, d]));
+			let p = new y.OperatorNode("and", "and", f);
+			return (t === "notsubset" || t === "notsuperset") && (p = new y.OperatorNode("not", "not", [p])), p;
+		}
+		if (t === "matrix") {
+			let e = n[0], t = e[1], r = e[2], i = n[1];
+			if (!Number.isInteger(t) || !Number.isInteger(r)) throw Error("Matrix must have integer dimensions");
+			let a = [];
+			for (let e = 1; e <= t; e++) {
+				let t = [];
+				for (let n = 1; n <= r; n++) t.push(this.convert(i[e][n]));
+				a.push(new y.ArrayNode(t));
+			}
+			return new y.ArrayNode(a);
+		}
+		if (t === "%") {
+			let e = this.convert(n[0]), t = new y.ConstantNode(100);
+			return new y.OperatorNode("/", "divide", [e, t]);
+		}
+		if (t in b) return b[t](n.map(function(e) {
+			return this.convert(e);
+		}.bind(this)));
+		throw Error("Operator " + t + " not implemented for conversion to mathjs");
+	}
+}, re = h, x = a("mv:node-sort"), S = (e, t) => (x("[compareNodes]: a:", e.toString(), e.type), x("[compareNodes]: b:", t.toString(), t.type), e.isSymbolNode && t.isSymbolNode ? e.name.localeCompare(t.name) : e.isConstantNode && t.isConstantNode ? (x("a.value", e.value), x("b.value", t.value), e.value - t.value) : e.isConstantNode && !t.isConstantNode ? -1 : t.isConstantNode && !e.isConstantNode ? 1 : e.isSymbolNode && (t.isOperatorNode || t.isFunctionNode) ? -1 : t.isSymbolNode && (e.isOperatorNode || t.isFunctionNode) ? 1 : e.isOperatorNode && t.isOperatorNode ? -e.args.toString().localeCompare(t.args.toString()) : !e.isFunctionNode && t.isFunctionNode ? -1 : NaN), C = (e) => ((e.fn === "add" || e.fn === "multiply") && (e.args = e.args.sort(S), e.args = e.args.map(C)), e), w = (e, t) => {
+	let n = !1;
+	return e.forEach((e) => {
+		e.fn === t && (n = !0);
+	}), n;
+}, ie = (e) => {
+	for (; e.isParenthesisNode && e.content;) e = e.content;
+	e = e.transform((e, t, n) => {
+		if (e.isParenthesisNode && (n?.op !== "*" || n?.op === "*" && e.content.op !== "+")) for (; e.isParenthesisNode;) e = e.content;
+		return e;
+	}), e.fn === "multiply" && e.implicit && (e.implicit = !1);
+	let t = e;
+	return t = t.transform((e) => {
+		for (; w(e, e.fn) && !e.isArrayNode;) e.traverse((e, t, n) => {
+			if (n?.fn === e.fn) {
+				let r = t.replace(/[^0-9]/g, "");
+				n.args.splice(+r, 1);
+				let i = n.args;
+				e.args.forEach((e) => {
+					i.push(e);
+				}), e = new re.OperatorNode(e.op, e.fn, i), e.fn === "multiply" && e.implicit && (e.implicit = !1);
+			}
+			return e;
+		});
+		return e;
+	}), t = t.transform((e) => {
+		if (e.fn === "multiply" && w(e.args, "divide")) {
+			let t = e;
+			if (t.fn === "multiply" && w(t, "divide")) {
+				let e;
+				return t = t.traverse((t, n, r) => {
+					if (r && r.fn === "multiply" && t.fn === "divide") {
+						if (t.args[0].isOperatorNode) r.args.forEach((e) => {
+							e.isOperatorNode || t.args[0].args.push(e);
+						});
+						else {
+							let e = [];
+							e.push(t.args[0]), r.args.forEach((t) => {
+								t.isOperatorNode || e.push(t);
+							}), t.args[0] = new re.OperatorNode("*", "multiply", e);
+						}
+						e = t;
+					}
+				}), e;
+			}
+		}
+		return e;
+	}), t;
+}, ae = (e) => {
+	x("THIS IS THE START ++++", JSON.stringify(e));
+	let t = ["smaller", "smallerEq"], n = ["larger", "largerEq"];
+	return e.transform((e, r, i) => {
+		let a = !1;
+		if (e.conditionals) {
+			let r = t.some((t) => e.conditionals.includes(t)) && n.some((t) => e.conditionals.includes(t));
+			e.conditionals.includes("equal") ? e.params.sort(S) : r && e.params ? S(e.params[0], e.params[e.params.length - 1]) > -1 && e.params.reverse() : e.conditionals = e.conditionals.map((e) => (e === "smaller" ? (a = !0, e = "larger") : e === "smallerEq" && (a = !0, e = "largerEq"), e));
+		}
+		return e.params && a && (e.conditionals.reverse(), e.params.reverse()), i && i.type === "RelationalNode" && e.args && (e = T(e)), e;
+	});
+}, T = (e) => {
+	let t = e;
+	return e.type === "RelationalNode" ? ae(e) : (e.isOperatorNode && e.fn === "smaller" && (e.op = ">", e.fn = "larger", e.args = e.args.reverse()), e.isOperatorNode && e.fn === "smallerEq" && (e.op = ">=", e.fn = "largerEq", e.args = e.args.reverse()), e.isFunctionNode && e.fn.name.match("=|NE|≃|≈|≈|≉|~|≃|≁|≅|≆") && (e.args = e.args.sort(S)), e.isOperatorNode && (e.fn === "larger" || e.fn === "largerEq" || e.fn === "equal" || e.fn === "unequal") && (e.args = e.args.map(T), (e.fn === "equal" || e.fn === "unequal") && (e.args = e.args.sort(S))), e.isArrayNode ? (e.items = e.items.sort(S), e) : (t = ie(e).transform(C), t));
+}, oe = [...Object.freeze([
+	{
+		l: "n1^(1/n2)",
+		r: "nthRoot(n1, n2)"
+	},
+	{
+		l: "sqrt(n1)",
+		r: "nthRoot(n1, 2)"
+	},
+	{
+		l: "nthRoot(-1, 2)",
+		r: "i"
+	},
+	{
+		l: "(v1-v2)/n",
+		r: "v1/n-v2/n"
+	},
+	{
+		l: "(v1-n)/n",
+		r: "v1/n-1"
+	},
+	{
+		l: "n/n1-c1",
+		r: "(n-c1*n1)/n1"
+	},
+	{
+		l: "i^2",
+		r: "-1"
+	},
+	{
+		l: "pi",
+		r: "3.141592653589793"
+	},
+	{
+		l: "n/(n*n1)",
+		r: "1/n1"
+	},
+	{
+		l: "c1/(c2*(n3))",
+		r: "(c1/c2)*(1/n3)"
+	},
+	{
+		l: "n1/(n(n+1)+1(n+1))",
+		r: "n1/((n+1)^2)"
+	},
+	{
+		l: "(n1 + n2) ^ 2",
+		r: "(n1 ^ 2) + 2*n1*n2 + (n2 ^ 2)"
+	},
+	_,
+	{
+		l: "n1/(-n2)",
+		r: "-(n1/n2)"
+	},
+	{
+		l: "sin(n*pi)",
+		r: "0"
+	},
+	{
+		l: "log(n1*n2, n3)",
+		r: "log(n1, n3)+log(n2,n3)"
+	},
+	{
+		l: "log(n1/n2, n3)",
+		r: "log(n1, n3)-log(n2,n3)"
+	},
+	{
+		l: "log(n1^n2, n3)",
+		r: "n2*log(n1,n3)"
+	},
+	{
+		l: "sin(n)/cos(n)",
+		r: "tan(n)"
+	},
+	{
+		l: "csc(n)",
+		r: "1/sin(n)"
+	},
+	{
+		l: "sec(n)",
+		r: "1/cos(n)"
+	},
+	{
+		l: "cot(n)",
+		r: "1/tan(n)",
+		r1: "cos(n)/sin(n)"
+	},
+	{
+		l: "1/tan(n)",
+		r: "cos(n)/sin(n)"
+	},
+	{
+		l: "n1 == asin(n)",
+		r: "n == sin(n1)"
+	},
+	{
+		l: "n1 == acos(n)",
+		r: "n == cos(n1)"
+	},
+	{
+		l: "n1 == atan(n)",
+		r: "n == tan(n1)"
+	},
+	{
+		l: "n1 == acot(n)",
+		r: "n == cot(n1)"
+	},
+	{
+		l: "n1 == asec(n)",
+		r: "n == sec(n1)"
+	},
+	{
+		l: "n1 == acsc(n)",
+		r: "n == csc(n1)"
+	},
+	{
+		l: "sin(asin(n))",
+		r: "n"
+	},
+	{
+		l: "cos(acos(n))",
+		r: "n"
+	},
+	{
+		l: "tan(atan(n))",
+		r: "n"
+	},
+	{
+		l: "sin(acsc(n))",
+		r: "1/n"
+	},
+	{
+		l: "cos(asec(n))",
+		r: "1/n"
+	},
+	{
+		l: "tan(acot(n))",
+		r: "1/n"
+	}
+]), ...h.simplify.rules], E = (e) => h.simplify(e, oe), D = h, se = Object.freeze([
+	{
+		l: "-((n1)*(n2))",
+		r: "(n1)*(n2)"
+	},
+	{
+		l: "(n1-n2)/n3",
+		r: "n1/n3-n2/n3"
+	},
+	{
+		l: "(n1+n2)/n3",
+		r: "n1/n3+n2/n3"
+	},
+	{
+		l: "(n1-n2)*n3/n4",
+		r: "(n1*n3)/n4-(n2*n3)/n4"
+	},
+	{
+		l: "(n1+n2)*n3/n4",
+		r: "(n1*n3)/n4+(n2*n3)/n4"
+	}
+]), ce = Object.freeze([...se, {
+	l: "-(n)",
+	r: "n"
+}]), O = (e) => Math.round(e * 0x9184e72a000) / 0x9184e72a000, le = (e, t) => {
+	let n = !0, r = !1, i = !1, a = !1;
+	return e.traverse((e) => {
+		e.isSymbolNode && (r = !0, a ||= e.name.includes("[")), n = n || !!e.isFunctionNode || !!e.isArrayNode;
+	}), t.traverse((e) => {
+		(e.isFunctionNode || e.isArrayNode) && (n = !1), e.isSymbolNode && r && (i = !0);
+	}), n && i && !a;
+}, ue = (e) => {
+	let t = !1;
+	return e.traverse((e) => {
+		e.isOperatorNode && e.op === "^" && !e.args[1]?.isConstantNode && (t = !0);
+	}), t;
+}, de = (e) => () => {
+	e = e + 1831565813 | 0;
+	let t = Math.imul(e ^ e >>> 15, 1 | e);
+	return t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t, ((t ^ t >>> 14) >>> 0) / 4294967296;
+}, fe = (e, t = 12) => {
+	let n = de(443);
+	return Array.from({ length: t }, () => e.reduce((e, t) => {
+		let r = .5 + 4 * n();
+		return e[t] = n() < .5 ? -r : r, e;
+	}, {}));
+}, k = (e, t) => {
+	let n;
+	try {
+		n = g.compile(e.toString());
+	} catch {
+		return t.map(() => NaN);
+	}
+	return t.map((e) => {
+		try {
+			let t = n.evaluate({ ...e });
+			return typeof t == "number" ? t : NaN;
+		} catch {
+			return NaN;
+		}
+	});
+}, A = (e, t, n) => Math.abs(e - t) <= n * Math.max(1, Math.abs(e), Math.abs(t)), pe = (e, t, n, r = 1e-10) => {
+	let i = fe(n), a = k(e, i), o = k(t, i);
+	return a.filter((e, t) => Number.isFinite(e) && Number.isFinite(o[t])).length >= 3 && a.every((e, t) => !Number.isFinite(e) || !Number.isFinite(o[t]) || A(e, o[t], r));
+}, me = (e, t) => e.reduce((e, n) => e.reduce((e, r) => e.concat(Array.from({ length: 2 * t + 1 }, (e, i) => ({
+	...r,
+	[n]: i - t
+}))), []), [{}]), j = (e, t, n, { allowVariableFactor: r = !1, positiveOnly: i = !1 } = {}) => {
+	let a = 1e-9, o = fe(n), s = k(e, o), c = k(t, o), l = [];
+	for (let e = 0; e < o.length; e++) {
+		let t = s[e], n = c[e];
+		if (!Number.isFinite(t) || !Number.isFinite(n)) continue;
+		let r = Math.abs(t) < a, i = Math.abs(n) < a;
+		if (!(r && i)) {
+			if (r || i) return !1;
+			l.push({
+				point: o[e],
+				ratio: t / n
+			});
+		}
+	}
+	return l.length < 3 ? !1 : (r ? me(n, 2).filter((e) => !i || Object.values(e).every((e) => e % 2 == 0)) : [{}]).some((e) => {
+		let t = l.map(({ point: t, ratio: n }) => Object.keys(e).reduce((n, r) => n / t[r] ** e[r], n));
+		return (!i || t[0] > 0) && t.every((e) => A(e, t[0], a));
+	});
+}, he = 4, ge = 60, _e = (e) => {
+	let t = 0, n = !1;
+	return e.traverse((e) => {
+		t++, n ||= e.isOperatorNode && e.op === "^" && e.args[1]?.isConstantNode && Math.abs(Number(e.args[1].value)) > he;
+	}), n || t > ge;
+}, M = (e) => {
+	if (!_e(e)) try {
+		let { numerator: t, denominator: n } = g.rationalize(e.toString(), {}, !0);
+		return n ? t : void 0;
+	} catch {
+		return;
+	}
+}, N = (e, t, n, r = {}) => {
+	if (j(e, t, n, r)) return !0;
+	if (r.positiveOnly) return !1;
+	let i = M(e), a = M(t);
+	return (i !== void 0 || a !== void 0) && j(i || e, a || t, n, r);
+}, P = (e) => E(new D.OperatorNode("-", "subtract", e.args)), F = (e) => {
+	let t = [];
+	return e.traverse((e) => {
+		e.isSymbolNode && e.name.length === 1 && !t.includes(e.name) && t.push(e.name);
+	}), t.sort();
+}, I = (e, t) => {
+	try {
+		let t = D.rationalize(e, {}, !0).coefficients;
+		return t.every((e) => e < 0) ? t.map((e) => Math.abs(e)) : t;
+	} catch {
+		e = D.simplify(e, t ? [...se] : [...ce]);
+		try {
+			return D.rationalize(e, {}, !0).coefficients;
+		} catch {}
+	}
+	return [1, 0];
+}, L = (e) => {
+	let [t, n, r] = e, i = n * n - 4 * r * t, a, o;
+	try {
+		a = D.compile(D.fraction(-n + D.sqrt(i)) / (2 * r));
+	} catch {
+		a = D.compile("(-b+sqrt(discriminant))/(2*a)");
+	}
+	try {
+		o = D.compile(D.fraction(-n - D.sqrt(i)) / (2 * r));
+	} catch {
+		o = D.compile("(-b-sqrt(discriminant))/(2*a)");
+	}
+	let s = a.evaluate({
+		discriminant: i,
+		a: r,
+		b: n
+	}), c = o.evaluate({
+		discriminant: i,
+		a: r,
+		b: n
+	});
+	return s.im ? [{
+		re: O(s.re),
+		im: O(s.im)
+	}, {
+		re: O(c.re),
+		im: O(c.im)
+	}] : (s = O(s), c = O(c), [{
+		re: s,
+		im: 0
+	}, {
+		re: c,
+		im: 0
+	}]);
+}, R = (e) => {
+	let t;
+	if (e) {
+		if (e.length === 3 && e[0] === 0 && (e = e.splice(1, 2)), e.length === 2) {
+			if (e[0] === 0 && e[1] === 0) return Infinity;
+			if (e[0] === 0) return 0;
+			t = O(D.divide(e[0], -1 * e[1]));
+		}
+		return t;
+	}
+}, z = (e, t) => Array.isArray(e) && Array.isArray(t) && e.length === t.length && e.every((e, n) => e === t[n]), B = h, V = (e, t, n) => {
+	let r = !1;
+	if (le(e, t)) {
+		let i = P(e), a = P(t);
+		if (i.equals(a)) return !0;
+		let o = F(i);
+		if (!z(o, F(a))) return !1;
+		let s, c;
+		if (ue(i) || ue(a)) return pe(i, a, o);
+		if (o.length === 1) {
+			if (s = I(i, n), c = I(a, n), z(s, c)) return !0;
+			if (s.length === 3 && c.length === 3 && !n && s[0] !== 0 || s.length === 4 && s[0] === 0 && c[0] === 0) {
+				s[0] === 0 && (s = s.splice(1, 3), c = c.splice(1, 3));
+				let e = L(s), t = L(c), n = B.complex(e), r = B.complex(t);
+				return e[0].im === 0 && e[1].im === 0 ? n[0].equals(r[0]) && n[1].equals(r[1]) || n[0].equals(r[1]) && n[1].equals(r[0]) : e[0].re === t[0].re && e[1].re === t[1].re && e[0].im.toFixed(13) === t[0].im.toFixed(13) && e[1].im.toFixed(13) === t[1].im.toFixed(13);
+			}
+			let e = R(s), t = R(c);
+			if (r = e === t && e !== void 0, !n && (e === void 0 || t === void 0)) return N(i, a, o);
+		}
+		if (o.length === 2) return N(i, a, o, {
+			allowVariableFactor: !0,
+			positiveOnly: n
+		});
+		if (r && n) return !(B.isPositive(s[0]) && B.isNegative(s[1]) && B.isNegative(c[0]) && B.isPositive(c[1]) || B.isNegative(s[0]) && B.isPositive(s[1]) && B.isPositive(c[0]) && B.isNegative(c[1]));
+	}
+	return r;
+}, H = h, U = (e) => {
+	switch (e) {
+		case "smaller": return "<";
+		case "smallerEq": return "<=";
+		case "larger": return ">";
+		case "largerEq": return ">=";
+		case "equal": return "==";
+		case "unequal": return "!=";
+	}
+}, W = (e) => ({
+	left: new H.OperatorNode(U(e.conditionals[0]), e.conditionals[0], [e.params[0], e.params[1]]),
+	right: new H.OperatorNode(U(e.conditionals[1]), e.conditionals[1], [e.params[1], e.params[2]])
+}), G = (e) => R(I(P(e), !0)), ve = ({ left: e, right: t }) => {
+	let n = G(t), r = G(e);
+	return {
+		min: Math.min(n, r),
+		max: Math.max(n, r)
+	};
+}, ye = (e, t) => {
+	if (!le(e, t)) return !1;
+	let n = F(e);
+	if (!z(n, F(t)) && n?.length === 1) return !1;
+	let r = W(e), i = W(t), a = ve(r), o = ve(i);
+	return a.min === o.min && a.max === o.max;
+}, K = h, q = a("mv:symbolic"), { rationalize: be } = h, xe = 1e-9, Se = 1e-13, Ce = 1e-14, we = (e, t) => {
+	let n = !1;
+	return e.traverse((e, r) => {
+		n ||= e.isSymbolNode && r !== "fn" && t(e.name);
+	}), n;
+}, Te = (e) => {
+	if (!we(e, (e) => e !== "pi" && e !== "Infinity")) try {
+		let t = g.evaluate(e.toString());
+		return typeof t == "number" ? t : void 0;
+	} catch {
+		return;
+	}
+}, Ee = (e) => {
+	let t = Te(e);
+	if (t === void 0 || !isFinite(t)) return;
+	let n = t / (Math.PI / 2), r = Math.round(n);
+	return Math.abs(n - r) <= xe * Math.max(1, Math.abs(r)) ? r : void 0;
+}, De = (e) => {
+	let t = !1, n = e.transform((e) => {
+		if (!e.isFunctionNode || e.args?.length !== 1) return e;
+		let n = Ee(e.args[0]);
+		if (n === void 0) return e;
+		let r = Math.abs(n) % 2 == 1, i = e;
+		switch (e.fn.name) {
+			case "sin":
+				i = r ? e : new K.ConstantNode(0);
+				break;
+			case "cos":
+				i = r ? new K.ConstantNode(0) : e;
+				break;
+			case "tan":
+				i = r ? new K.SymbolNode("Infinity") : new K.ConstantNode(0);
+				break;
+			case "cot":
+				i = r ? new K.ConstantNode(0) : new K.SymbolNode("Infinity");
+				break;
+			case "sec":
+				i = r ? new K.SymbolNode("Infinity") : e;
+				break;
+			case "csc": i = r ? e : new K.SymbolNode("Infinity");
+		}
+		return t ||= i !== e, i;
+	});
+	return {
+		r: t ? n : e,
+		changed: t
+	};
+}, J = (e) => {
+	let t = De(e), n = t.r, r = t.changed ? Te(n) : void 0, i = r !== void 0 && (!isFinite(r) || we(n, (e) => e === "Infinity")) ? r : void 0, a = !0, o = !1, s = !1, c = !1, l = !1;
+	if (n.traverse((e) => {
+		e.isArrayNode && (s = !0, e.items = e.items.map((e) => E(e))), e.isSymbolNode && (c ||= e.name === "pi", l ||= e.name === "f^{-1}");
+	}), n.args && (n.args = n.args.map((e) => {
+		if (!e.isFunctionNode && !e.isArrayNode && !l && !c) try {
+			e = E(e);
+		} catch {}
+		return o ||= e.isFunctionNode, a &&= !!e.isConstantNode, e;
+	}), (o || l) && (n.args = n.args.map((e) => {
+		if (!e.isFunctionNode && !e.isArrayNode) try {
+			e = be(E(e), {}, !0).expression;
+		} catch {}
+		return e;
+	}))), n.fn !== "equal") try {
+		a = !1, n = be(n, {}, !0).expression;
+	} catch {}
+	if (n.conditionals && n.params && (n.params = n.params.map((e) => T(E(e)))), !s && !a) try {
+		n = E(n);
+	} catch {}
+	return q("[normalize] input: ", e.toString(), "output: ", n.toString()), i !== void 0 && (n = isNaN(i) ? new K.SymbolNode("NaN") : isFinite(i) ? new K.ConstantNode(i) : new K.SymbolNode("Infinity")), n.toString() === "Infinity" && (n = new K.SymbolNode("Infinity")), n;
+}, Oe = (e) => {
+	if (!(e.filter((e) => e.isSymbolNode).length > 0)) try {
+		let t = e.evaluate();
+		if (typeof t == "boolean") return;
+		let n = +t;
+		return Number.isFinite(n) ? n : void 0;
+	} catch {
+		return;
+	}
+}, ke = (e, t) => Math.abs(e - t) < Ce + Se * Math.max(Math.abs(e), Math.abs(t)), Ae = (e) => e?.isSymbolNode && e.name === "NaN", je = (e, t) => {
+	let n, r;
+	if (e?.isUnit && t?.isUnit) try {
+		return K.equal(e, t);
+	} catch (n) {
+		return q("[isMathEqual] Error comparing units:", e?.toString?.(), t?.toString?.(), n), !1;
+	}
+	if (e?.isUnit || t?.isUnit) return q("[isMathEqual] Mismatched unit comparison:", e?.toString?.(), t?.toString?.()), !1;
+	if (n = e.conditionals ? J(e) : T(J(e)), r = t.conditionals ? J(t) : T(J(t)), q("[isMathEqual]", n.toString(), "==?", r.toString()), Ae(n) || Ae(r)) return !1;
+	let i = T(e).equals(T(t)), a = n.toTex().trim() === r.toTex().trim() || n.equals(r) || i;
+	if (a) return !0;
+	let o = Oe(n), s = Oe(r);
+	if (o !== void 0 && s !== void 0) return ke(o, s);
+	if (n.fn === "equal" && r.fn === "equal") return V(n, r, !1);
+	if (n.fn === "larger" && r.fn === "larger" || n.fn === "largerEq" && r.fn === "largerEq") return n.fn = "equal", r.fn = "equal", n.op = "=", r.op = "=", V(n, r, !0);
+	if (n?.conditionals?.length === r?.conditionals?.length && n?.conditionals?.length === 2 && n?.conditionals?.toString() === r?.conditionals?.toString()) {
+		let e = [
+			"smaller",
+			"smallerEq",
+			"larger",
+			"largerEq",
+			"equal",
+			"unequal"
+		], t = e.some((e) => n.conditionals.includes(e)), i = e.some((e) => r.conditionals.includes(e));
+		if (t && i) return ye(n, r);
+	}
+	return a;
+}, { simplify: Me } = h, Ne = (e, t, n) => (n && n.allowTrailingZeros && (e = Me(e, [_]), t = Me(t, [_])), n && n.ignoreOrder && (e = T(e), t = T(t)), e.equals(t)), Pe = a("mv:difference"), Fe = (e, t) => {
+	let n = Math.min(e.toString().length, t.toString().length), r = Math.max(e.toString().length, t.toString().length), i = 1 / n * 100 + 10 + 17, a = r - n;
+	return Pe("a:", e.toString(), "b:", t.toString(), "limit:", i, "diff:", a), a > i;
+}, Ie = new m({ keepMixedNumbers: !0 }), Le = (e, t) => t === 0 ? Math.abs(e) : Le(t, e % t), Y = (e, t) => {
+	if (!Number.isFinite(e) || !Number.isFinite(t) || t === 0) return;
+	let n = Le(e, t) || 1, r = t < 0 ? -1 : 1;
+	return {
+		n: r * e / n,
+		d: r * t / n
+	};
+}, X = (e) => e && {
+	n: -e.n,
+	d: e.d
+}, Re = (e, t) => e && t && t.n !== 0 ? Y(e.n * t.d, e.d * t.n) : void 0, Z = (e, t, n) => Array.isArray(e) && e[0] === t && e.length === n + 1, Q = (e) => {
+	let t = Z(e, "tzn", 2) ? e[1] : e;
+	if (typeof t != "number" || !Number.isFinite(t) || t < 0) return;
+	let n = /^(\d+)(?:\.(\d+))?(?:e([+-]\d+))?$/.exec(String(t));
+	if (!n) return;
+	let [, r, i = "", a = "0"] = n, o = Number(r + i), s = Number(a) - i.length;
+	return s >= 0 ? Y(o * 10 ** s, 1) : Y(o, 10 ** -s);
+}, $ = (e) => typeof e == "number" && Number.isInteger(e) ? Q(e) : void 0, ze = (e) => Z(e, "-", 1) ? X(Q(e[1])) : Q(e), Be = (e) => {
+	if (Z(e, "/", 2)) return Re(ze(e[1]), ze(e[2]));
+	if (Z(e, "mixed", 2) && Z(e[2], "/", 2)) {
+		let t = $(e[1]), n = Re($(e[2][1]), $(e[2][2]));
+		return t && n && Y(t.n * n.d + n.n, n.d);
+	}
+	return Q(e);
+}, Ve = (e) => {
+	if (typeof e != "string" || !e.trim()) return;
+	let t;
+	try {
+		t = Ie.convert(e);
+	} catch {
+		return;
+	}
+	return Z(t, "-", 1) ? X(Be(t[1])) : Be(t);
+}, He = (e, t) => {
+	let n = Ve(e), r = Ve(t);
+	if (n || r) return !!n && !!r && n.n === r.n && n.d === r.d;
+}, Ue = new m(), We = new ne(), Ge = (e, t, n) => {
+	let r = (e) => /^\s*-?\d+(\.\d+)?\s*$/.test(e);
+	if (!e || !t) return !1;
+	if (e === t) return !0;
+	if (n.mode === "literal" && n.literal?.compareNumbersByValue) {
+		let n = He(e, t);
+		if (n !== void 0) return n;
+	}
+	if (n.mode === "symbolic" && r(e) && r(t) && parseFloat(e) === parseFloat(t)) return !0;
+	let i = Ue.convert(e), a = Ue.convert(t);
+	if (Fe(i, a)) return !1;
+	let o = We.convert(i), s = We.convert(a);
+	return n.mode === "literal" ? Ne(o, s, n.literal) : je(o, s);
+};
+export { Ge as latexEqual };