!(function (t) {
	var e = {};
	function a(n) {
		if (e[n]) return e[n].exports;
		var o = (e[n] = { i: n, l: !1, exports: {} });
		return t[n].call(o.exports, o, o.exports, a), (o.l = !0), o.exports;
	}
	(a.m = t),
		(a.c = e),
		(a.d = function (t, e, n) {
			a.o(t, e) || Object.defineProperty(t, e, { enumerable: !0, get: n });
		}),
		(a.r = function (t) {
			"undefined" != typeof Symbol &&
				Symbol.toStringTag &&
				Object.defineProperty(t, Symbol.toStringTag, { value: "Module" }),
				Object.defineProperty(t, "__esModule", { value: !0 });
		}),
		(a.t = function (t, e) {
			if ((1 & e && (t = a(t)), 8 & e)) return t;
			if (4 & e && "object" == typeof t && t && t.__esModule) return t;
			var n = Object.create(null);
			if (
				(a.r(n),
				Object.defineProperty(n, "default", { enumerable: !0, value: t }),
				2 & e && "string" != typeof t)
			)
				for (var o in t)
					a.d(
						n,
						o,
						function (e) {
							return t[e];
						}.bind(null, o),
					);
			return n;
		}),
		(a.n = function (t) {
			var e =
				t && t.__esModule
					? function () {
							return t.default;
						}
					: function () {
							return t;
						};
			return a.d(e, "a", e), e;
		}),
		(a.o = function (t, e) {
			return Object.prototype.hasOwnProperty.call(t, e);
		}),
		(a.p = ""),
		a((a.s = 8));
})([
	function (t, e, a) {
		"use strict";
		Object.defineProperty(e, "__esModule", { value: !0 }),
			(e.isObject = MathJax._.components.global.isObject),
			(e.combineConfig = MathJax._.components.global.combineConfig),
			(e.combineDefaults = MathJax._.components.global.combineDefaults),
			(e.combineWithMathJax = MathJax._.components.global.combineWithMathJax),
			(e.MathJax = MathJax._.components.global.MathJax);
	},
	function (t, e, a) {
		"use strict";
		Object.defineProperty(e, "__esModule", { value: !0 }),
			(e.MhchemConfiguration = void 0);
		var n = a(2),
			o = a(3),
			r = a(4),
			i = a(5),
			c = a(6),
			u = a(7),
			p = {};
		(p.Macro = i.default.Macro),
			(p.xArrow = c.AmsMethods.xArrow),
			(p.Machine = function (t, e, a) {
				try {
					var n = t.GetArgument(e),
						o = u.mhchemParser.go(n, a),
						i = u.texify.go(o);
					(t.string = i + t.string.substr(t.i)), (t.i = 0);
				} catch (t) {
					throw new r.default(t[0], t[1], t.slice(2));
				}
			}),
			new o.CommandMap(
				"mhchem",
				{
					ce: ["Machine", "ce"],
					pu: ["Machine", "pu"],
					longrightleftharpoons: [
						"Macro",
						"\\stackrel{\\textstyle{-}\\!\\!{\\rightharpoonup}}{\\smash{{\\leftharpoondown}\\!\\!{-}}}",
					],
					longRightleftharpoons: [
						"Macro",
						"\\stackrel{\\textstyle{-}\\!\\!{\\rightharpoonup}}{\\smash{\\leftharpoondown}}",
					],
					longLeftrightharpoons: [
						"Macro",
						"\\stackrel{\\textstyle\\vphantom{{-}}{\\rightharpoonup}}{\\smash{{\\leftharpoondown}\\!\\!{-}}}",
					],
					longleftrightarrows: [
						"Macro",
						"\\stackrel{\\longrightarrow}{\\smash{\\longleftarrow}\\Rule{0px}{.25em}{0px}}",
					],
					tripledash: [
						"Macro",
						"\\vphantom{-}\\raise2mu{\\kern2mu\\tiny\\text{-}\\kern1mu\\text{-}\\kern1mu\\text{-}\\kern2mu}",
					],
					xrightarrow: ["xArrow", 8594, 5, 6],
					xleftarrow: ["xArrow", 8592, 7, 3],
					xleftrightarrow: ["xArrow", 8596, 6, 6],
					xrightleftharpoons: ["xArrow", 8652, 5, 7],
					xRightleftharpoons: ["xArrow", 8652, 5, 7],
					xLeftrightharpoons: ["xArrow", 8652, 5, 7],
				},
				p,
			),
			(e.MhchemConfiguration = n.Configuration.create("mhchem", {
				handler: { macro: ["mhchem"] },
			}));
	},
	function (t, e, a) {
		"use strict";
		Object.defineProperty(e, "__esModule", { value: !0 }),
			(e.Configuration = MathJax._.input.tex.Configuration.Configuration),
			(e.ConfigurationHandler =
				MathJax._.input.tex.Configuration.ConfigurationHandler),
			(e.ParserConfiguration =
				MathJax._.input.tex.Configuration.ParserConfiguration);
	},
	function (t, e, a) {
		"use strict";
		Object.defineProperty(e, "__esModule", { value: !0 }),
			(e.AbstractSymbolMap = MathJax._.input.tex.SymbolMap.AbstractSymbolMap),
			(e.RegExpMap = MathJax._.input.tex.SymbolMap.RegExpMap),
			(e.AbstractParseMap = MathJax._.input.tex.SymbolMap.AbstractParseMap),
			(e.CharacterMap = MathJax._.input.tex.SymbolMap.CharacterMap),
			(e.DelimiterMap = MathJax._.input.tex.SymbolMap.DelimiterMap),
			(e.MacroMap = MathJax._.input.tex.SymbolMap.MacroMap),
			(e.CommandMap = MathJax._.input.tex.SymbolMap.CommandMap),
			(e.EnvironmentMap = MathJax._.input.tex.SymbolMap.EnvironmentMap);
	},
	function (t, e, a) {
		"use strict";
		Object.defineProperty(e, "__esModule", { value: !0 }),
			(e.default = MathJax._.input.tex.TexError.default);
	},
	function (t, e, a) {
		"use strict";
		Object.defineProperty(e, "__esModule", { value: !0 }),
			(e.default = MathJax._.input.tex.base.BaseMethods.default);
	},
	function (t, e, a) {
		"use strict";
		Object.defineProperty(e, "__esModule", { value: !0 }),
			(e.AmsMethods = MathJax._.input.tex.ams.AmsMethods.AmsMethods),
			(e.NEW_OPS = MathJax._.input.tex.ams.AmsMethods.NEW_OPS);
	},
	function (t, e, a) {
		"use strict";
		Object.defineProperty(e, "__esModule", { value: !0 });
		var n = {
			go: function (t, e) {
				if (!t) return [];
				void 0 === e && (e = "ce");
				var a,
					o = "0",
					r = {};
				(r.parenthesisLevel = 0),
					(t = (t = (t = t.replace(/\n/g, " ")).replace(
						/[\u2212\u2013\u2014\u2010]/g,
						"-",
					)).replace(/[\u2026]/g, "..."));
				for (var i = 10, c = []; ; ) {
					a !== t ? ((i = 10), (a = t)) : i--;
					var u = n.stateMachines[e],
						p = u.transitions[o] || u.transitions["*"];
					t: for (var s = 0; s < p.length; s++) {
						var _ = n.patterns.match_(p[s].pattern, t);
						if (_) {
							for (var d = p[s].task, l = 0; l < d.action_.length; l++) {
								var m;
								if (u.actions[d.action_[l].type_])
									m = u.actions[d.action_[l].type_](
										r,
										_.match_,
										d.action_[l].option,
									);
								else {
									if (!n.actions[d.action_[l].type_])
										throw [
											"MhchemBugA",
											"mhchem bug A. Please report. (" +
												d.action_[l].type_ +
												")",
										];
									m = n.actions[d.action_[l].type_](
										r,
										_.match_,
										d.action_[l].option,
									);
								}
								n.concatArray(c, m);
							}
							if (((o = d.nextState || o), !(t.length > 0))) return c;
							if ((d.revisit || (t = _.remainder), !d.toContinue)) break t;
						}
					}
					if (i <= 0) throw ["MhchemBugU", "mhchem bug U. Please report."];
				}
			},
			concatArray: function (t, e) {
				if (e)
					if (Array.isArray(e)) for (var a = 0; a < e.length; a++) t.push(e[a]);
					else t.push(e);
			},
			patterns: {
				patterns: {
					empty: /^$/,
					else: /^./,
					else2: /^./,
					space: /^\s/,
					"space A": /^\s(?=[A-Z\\$])/,
					space$: /^\s$/,
					"a-z": /^[a-z]/,
					x: /^x/,
					x$: /^x$/,
					i$: /^i$/,
					letters:
						/^(?:[a-zA-Z\u03B1-\u03C9\u0391-\u03A9?@]|(?:\\(?:alpha|beta|gamma|delta|epsilon|zeta|eta|theta|iota|kappa|lambda|mu|nu|xi|omicron|pi|rho|sigma|tau|upsilon|phi|chi|psi|omega|Gamma|Delta|Theta|Lambda|Xi|Pi|Sigma|Upsilon|Phi|Psi|Omega)(?:\s+|\{\}|(?![a-zA-Z]))))+/,
					"\\greek":
						/^\\(?:alpha|beta|gamma|delta|epsilon|zeta|eta|theta|iota|kappa|lambda|mu|nu|xi|omicron|pi|rho|sigma|tau|upsilon|phi|chi|psi|omega|Gamma|Delta|Theta|Lambda|Xi|Pi|Sigma|Upsilon|Phi|Psi|Omega)(?:\s+|\{\}|(?![a-zA-Z]))/,
					"one lowercase latin letter $": /^(?:([a-z])(?:$|[^a-zA-Z]))$/,
					"$one lowercase latin letter$ $": /^\$(?:([a-z])(?:$|[^a-zA-Z]))\$$/,
					"one lowercase greek letter $":
						/^(?:\$?[\u03B1-\u03C9]\$?|\$?\\(?:alpha|beta|gamma|delta|epsilon|zeta|eta|theta|iota|kappa|lambda|mu|nu|xi|omicron|pi|rho|sigma|tau|upsilon|phi|chi|psi|omega)\s*\$?)(?:\s+|\{\}|(?![a-zA-Z]))$/,
					digits: /^[0-9]+/,
					"-9.,9": /^[+\-]?(?:[0-9]+(?:[,.][0-9]+)?|[0-9]*(?:\.[0-9]+))/,
					"-9.,9 no missing 0": /^[+\-]?[0-9]+(?:[.,][0-9]+)?/,
					"(-)(9.,9)(e)(99)": function (t) {
						var e = t.match(
							/^(\+\-|\+\/\-|\+|\-|\\pm\s?)?([0-9]+(?:[,.][0-9]+)?|[0-9]*(?:\.[0-9]+))?(\((?:[0-9]+(?:[,.][0-9]+)?|[0-9]*(?:\.[0-9]+))\))?(?:([eE]|\s*(\*|x|\\times|\u00D7)\s*10\^)([+\-]?[0-9]+|\{[+\-]?[0-9]+\}))?/,
						);
						return e && e[0]
							? { match_: e.splice(1), remainder: t.substr(e[0].length) }
							: null;
					},
					"(-)(9)^(-9)": function (t) {
						var e = t.match(
							/^(\+\-|\+\/\-|\+|\-|\\pm\s?)?([0-9]+(?:[,.][0-9]+)?|[0-9]*(?:\.[0-9]+)?)\^([+\-]?[0-9]+|\{[+\-]?[0-9]+\})/,
						);
						return e && e[0]
							? { match_: e.splice(1), remainder: t.substr(e[0].length) }
							: null;
					},
					"state of aggregation $": function (t) {
						var e = n.patterns.findObserveGroups(
							t,
							"",
							/^\([a-z]{1,3}(?=[\),])/,
							")",
							"",
						);
						if (e && e.remainder.match(/^($|[\s,;\)\]\}])/)) return e;
						var a = t.match(/^(?:\((?:\\ca\s?)?\$[amothc]\$\))/);
						return a
							? { match_: a[0], remainder: t.substr(a[0].length) }
							: null;
					},
					"_{(state of aggregation)}$": /^_\{(\([a-z]{1,3}\))\}/,
					"{[(": /^(?:\\\{|\[|\()/,
					")]}": /^(?:\)|\]|\\\})/,
					", ": /^[,;]\s*/,
					",": /^[,;]/,
					".": /^[.]/,
					". ": /^([.\u22C5\u00B7\u2022])\s*/,
					"...": /^\.\.\.(?=$|[^.])/,
					"* ": /^([*])\s*/,
					"^{(...)}": function (t) {
						return n.patterns.findObserveGroups(t, "^{", "", "", "}");
					},
					"^($...$)": function (t) {
						return n.patterns.findObserveGroups(t, "^", "$", "$", "");
					},
					"^a": /^\^([0-9]+|[^\\_])/,
					"^\\x{}{}": function (t) {
						return n.patterns.findObserveGroups(
							t,
							"^",
							/^\\[a-zA-Z]+\{/,
							"}",
							"",
							"",
							"{",
							"}",
							"",
							!0,
						);
					},
					"^\\x{}": function (t) {
						return n.patterns.findObserveGroups(
							t,
							"^",
							/^\\[a-zA-Z]+\{/,
							"}",
							"",
						);
					},
					"^\\x": /^\^(\\[a-zA-Z]+)\s*/,
					"^(-1)": /^\^(-?\d+)/,
					"'": /^'/,
					"_{(...)}": function (t) {
						return n.patterns.findObserveGroups(t, "_{", "", "", "}");
					},
					"_($...$)": function (t) {
						return n.patterns.findObserveGroups(t, "_", "$", "$", "");
					},
					_9: /^_([+\-]?[0-9]+|[^\\])/,
					"_\\x{}{}": function (t) {
						return n.patterns.findObserveGroups(
							t,
							"_",
							/^\\[a-zA-Z]+\{/,
							"}",
							"",
							"",
							"{",
							"}",
							"",
							!0,
						);
					},
					"_\\x{}": function (t) {
						return n.patterns.findObserveGroups(
							t,
							"_",
							/^\\[a-zA-Z]+\{/,
							"}",
							"",
						);
					},
					"_\\x": /^_(\\[a-zA-Z]+)\s*/,
					"^_": /^(?:\^(?=_)|\_(?=\^)|[\^_]$)/,
					"{}": /^\{\}/,
					"{...}": function (t) {
						return n.patterns.findObserveGroups(t, "", "{", "}", "");
					},
					"{(...)}": function (t) {
						return n.patterns.findObserveGroups(t, "{", "", "", "}");
					},
					"$...$": function (t) {
						return n.patterns.findObserveGroups(t, "", "$", "$", "");
					},
					"${(...)}$": function (t) {
						return n.patterns.findObserveGroups(t, "${", "", "", "}$");
					},
					"$(...)$": function (t) {
						return n.patterns.findObserveGroups(t, "$", "", "", "$");
					},
					"=<>": /^[=<>]/,
					"#": /^[#\u2261]/,
					"+": /^\+/,
					"-$": /^-(?=[\s_},;\]/]|$|\([a-z]+\))/,
					"-9": /^-(?=[0-9])/,
					"- orbital overlap": /^-(?=(?:[spd]|sp)(?:$|[\s,;\)\]\}]))/,
					"-": /^-/,
					"pm-operator": /^(?:\\pm|\$\\pm\$|\+-|\+\/-)/,
					operator:
						/^(?:\+|(?:[\-=<>]|<<|>>|\\approx|\$\\approx\$)(?=\s|$|-?[0-9]))/,
					arrowUpDown: /^(?:v|\(v\)|\^|\(\^\))(?=$|[\s,;\)\]\}])/,
					"\\bond{(...)}": function (t) {
						return n.patterns.findObserveGroups(t, "\\bond{", "", "", "}");
					},
					"->": /^(?:<->|<-->|->|<-|<=>>|<<=>|<=>|[\u2192\u27F6\u21CC])/,
					CMT: /^[CMT](?=\[)/,
					"[(...)]": function (t) {
						return n.patterns.findObserveGroups(t, "[", "", "", "]");
					},
					"1st-level escape": /^(&|\\\\|\\hline)\s*/,
					"\\,": /^(?:\\[,\ ;:])/,
					"\\x{}{}": function (t) {
						return n.patterns.findObserveGroups(
							t,
							"",
							/^\\[a-zA-Z]+\{/,
							"}",
							"",
							"",
							"{",
							"}",
							"",
							!0,
						);
					},
					"\\x{}": function (t) {
						return n.patterns.findObserveGroups(
							t,
							"",
							/^\\[a-zA-Z]+\{/,
							"}",
							"",
						);
					},
					"\\ca": /^\\ca(?:\s+|(?![a-zA-Z]))/,
					"\\x": /^(?:\\[a-zA-Z]+\s*|\\[_&{}%])/,
					orbital: /^(?:[0-9]{1,2}[spdfgh]|[0-9]{0,2}sp)(?=$|[^a-zA-Z])/,
					others: /^[\/~|]/,
					"\\frac{(...)}": function (t) {
						return n.patterns.findObserveGroups(
							t,
							"\\frac{",
							"",
							"",
							"}",
							"{",
							"",
							"",
							"}",
						);
					},
					"\\overset{(...)}": function (t) {
						return n.patterns.findObserveGroups(
							t,
							"\\overset{",
							"",
							"",
							"}",
							"{",
							"",
							"",
							"}",
						);
					},
					"\\underset{(...)}": function (t) {
						return n.patterns.findObserveGroups(
							t,
							"\\underset{",
							"",
							"",
							"}",
							"{",
							"",
							"",
							"}",
						);
					},
					"\\underbrace{(...)}": function (t) {
						return n.patterns.findObserveGroups(
							t,
							"\\underbrace{",
							"",
							"",
							"}_",
							"{",
							"",
							"",
							"}",
						);
					},
					"\\color{(...)}0": function (t) {
						return n.patterns.findObserveGroups(t, "\\color{", "", "", "}");
					},
					"\\color{(...)}{(...)}1": function (t) {
						return n.patterns.findObserveGroups(
							t,
							"\\color{",
							"",
							"",
							"}",
							"{",
							"",
							"",
							"}",
						);
					},
					"\\color(...){(...)}2": function (t) {
						return n.patterns.findObserveGroups(
							t,
							"\\color",
							"\\",
							"",
							/^(?=\{)/,
							"{",
							"",
							"",
							"}",
						);
					},
					"\\ce{(...)}": function (t) {
						return n.patterns.findObserveGroups(t, "\\ce{", "", "", "}");
					},
					oxidation$: /^(?:[+-][IVX]+|\\pm\s*0|\$\\pm\$\s*0)$/,
					"d-oxidation$": /^(?:[+-]?\s?[IVX]+|\\pm\s*0|\$\\pm\$\s*0)$/,
					"roman numeral": /^[IVX]+/,
					"1/2$":
						/^[+\-]?(?:[0-9]+|\$[a-z]\$|[a-z])\/[0-9]+(?:\$[a-z]\$|[a-z])?$/,
					amount: function (t) {
						var e;
						if (
							(e = t.match(
								/^(?:(?:(?:\([+\-]?[0-9]+\/[0-9]+\)|[+\-]?(?:[0-9]+|\$[a-z]\$|[a-z])\/[0-9]+|[+\-]?[0-9]+[.,][0-9]+|[+\-]?\.[0-9]+|[+\-]?[0-9]+)(?:[a-z](?=\s*[A-Z]))?)|[+\-]?[a-z](?=\s*[A-Z])|\+(?!\s))/,
							))
						)
							return { match_: e[0], remainder: t.substr(e[0].length) };
						var a = n.patterns.findObserveGroups(t, "", "$", "$", "");
						return a &&
							(e = a.match_.match(
								/^\$(?:\(?[+\-]?(?:[0-9]*[a-z]?[+\-])?[0-9]*[a-z](?:[+\-][0-9]*[a-z]?)?\)?|\+|-)\$$/,
							))
							? { match_: e[0], remainder: t.substr(e[0].length) }
							: null;
					},
					amount2: function (t) {
						return this.amount(t);
					},
					"(KV letters),": /^(?:[A-Z][a-z]{0,2}|i)(?=,)/,
					formula$: function (t) {
						if (t.match(/^\([a-z]+\)$/)) return null;
						var e = t.match(
							/^(?:[a-z]|(?:[0-9\ \+\-\,\.\(\)]+[a-z])+[0-9\ \+\-\,\.\(\)]*|(?:[a-z][0-9\ \+\-\,\.\(\)]+)+[a-z]?)$/,
						);
						return e
							? { match_: e[0], remainder: t.substr(e[0].length) }
							: null;
					},
					uprightEntities: /^(?:pH|pOH|pC|pK|iPr|iBu)(?=$|[^a-zA-Z])/,
					"/": /^\s*(\/)\s*/,
					"//": /^\s*(\/\/)\s*/,
					"*": /^\s*[*.]\s*/,
				},
				findObserveGroups: function (t, e, a, n, o, r, i, c, u, p) {
					var s = function (t, e) {
							if ("string" == typeof e) return 0 !== t.indexOf(e) ? null : e;
							var a = t.match(e);
							return a ? a[0] : null;
						},
						_ = s(t, e);
					if (null === _) return null;
					if (((t = t.substr(_.length)), null === (_ = s(t, a)))) return null;
					var d = (function (t, e, a) {
						for (var n = 0; e < t.length; ) {
							var o = t.charAt(e),
								r = s(t.substr(e), a);
							if (null !== r && 0 === n)
								return { endMatchBegin: e, endMatchEnd: e + r.length };
							if ("{" === o) n++;
							else if ("}" === o) {
								if (0 === n)
									throw [
										"ExtraCloseMissingOpen",
										"Extra close brace or missing open brace",
									];
								n--;
							}
							e++;
						}
						return null;
					})(t, _.length, n || o);
					if (null === d) return null;
					var l = t.substring(0, n ? d.endMatchEnd : d.endMatchBegin);
					if (r || i) {
						var m = this.findObserveGroups(t.substr(d.endMatchEnd), r, i, c, u);
						if (null === m) return null;
						var h = [l, m.match_];
						return { match_: p ? h.join("") : h, remainder: m.remainder };
					}
					return { match_: l, remainder: t.substr(d.endMatchEnd) };
				},
				match_: function (t, e) {
					var a = n.patterns.patterns[t];
					if (void 0 === a)
						throw ["MhchemBugP", "mhchem bug P. Please report. (" + t + ")"];
					if ("function" == typeof a) return n.patterns.patterns[t](e);
					var o = e.match(a);
					return o
						? {
								match_: o[2] ? [o[1], o[2]] : o[1] ? o[1] : o[0],
								remainder: e.substr(o[0].length),
							}
						: null;
				},
			},
			actions: {
				"a=": function (t, e) {
					t.a = (t.a || "") + e;
				},
				"b=": function (t, e) {
					t.b = (t.b || "") + e;
				},
				"p=": function (t, e) {
					t.p = (t.p || "") + e;
				},
				"o=": function (t, e) {
					t.o = (t.o || "") + e;
				},
				"q=": function (t, e) {
					t.q = (t.q || "") + e;
				},
				"d=": function (t, e) {
					t.d = (t.d || "") + e;
				},
				"rm=": function (t, e) {
					t.rm = (t.rm || "") + e;
				},
				"text=": function (t, e) {
					t.text_ = (t.text_ || "") + e;
				},
				insert: function (t, e, a) {
					return { type_: a };
				},
				"insert+p1": function (t, e, a) {
					return { type_: a, p1: e };
				},
				"insert+p1+p2": function (t, e, a) {
					return { type_: a, p1: e[0], p2: e[1] };
				},
				copy: function (t, e) {
					return e;
				},
				rm: function (t, e) {
					return { type_: "rm", p1: e || "" };
				},
				text: function (t, e) {
					return n.go(e, "text");
				},
				"{text}": function (t, e) {
					var a = ["{"];
					return n.concatArray(a, n.go(e, "text")), a.push("}"), a;
				},
				"tex-math": function (t, e) {
					return n.go(e, "tex-math");
				},
				"tex-math tight": function (t, e) {
					return n.go(e, "tex-math tight");
				},
				bond: function (t, e, a) {
					return { type_: "bond", kind_: a || e };
				},
				"color0-output": function (t, e) {
					return { type_: "color0", color: e[0] };
				},
				ce: function (t, e) {
					return n.go(e);
				},
				"1/2": function (t, e) {
					var a = [];
					e.match(/^[+\-]/) && (a.push(e.substr(0, 1)), (e = e.substr(1)));
					var n = e.match(
						/^([0-9]+|\$[a-z]\$|[a-z])\/([0-9]+)(\$[a-z]\$|[a-z])?$/,
					);
					return (
						(n[1] = n[1].replace(/\$/g, "")),
						a.push({ type_: "frac", p1: n[1], p2: n[2] }),
						n[3] &&
							((n[3] = n[3].replace(/\$/g, "")),
							a.push({ type_: "tex-math", p1: n[3] })),
						a
					);
				},
				"9,9": function (t, e) {
					return n.go(e, "9,9");
				},
			},
			createTransitions: function (t) {
				var e,
					a,
					n,
					o,
					r = {};
				for (e in t)
					for (a in t[e])
						for (
							n = a.split("|"), t[e][a].stateArray = n, o = 0;
							o < n.length;
							o++
						)
							r[n[o]] = [];
				for (e in t)
					for (a in t[e])
						for (n = t[e][a].stateArray || [], o = 0; o < n.length; o++) {
							var i = t[e][a];
							if (i.action_) {
								i.action_ = [].concat(i.action_);
								for (var c = 0; c < i.action_.length; c++)
									"string" == typeof i.action_[c] &&
										(i.action_[c] = { type_: i.action_[c] });
							} else i.action_ = [];
							for (var u = e.split("|"), p = 0; p < u.length; p++)
								if ("*" === n[o])
									for (var s in r) r[s].push({ pattern: u[p], task: i });
								else r[n[o]].push({ pattern: u[p], task: i });
						}
				return r;
			},
			stateMachines: {},
		};
		n.stateMachines = {
			ce: {
				transitions: n.createTransitions({
					empty: { "*": { action_: "output" } },
					else: {
						"0|1|2": {
							action_: "beginsWithBond=false",
							revisit: !0,
							toContinue: !0,
						},
					},
					oxidation$: { 0: { action_: "oxidation-output" } },
					CMT: {
						r: { action_: "rdt=", nextState: "rt" },
						rd: { action_: "rqt=", nextState: "rdt" },
					},
					arrowUpDown: {
						"0|1|2|as": {
							action_: ["sb=false", "output", "operator"],
							nextState: "1",
						},
					},
					uprightEntities: {
						"0|1|2": { action_: ["o=", "output"], nextState: "1" },
					},
					orbital: { "0|1|2|3": { action_: "o=", nextState: "o" } },
					"->": {
						"0|1|2|3": { action_: "r=", nextState: "r" },
						"a|as": { action_: ["output", "r="], nextState: "r" },
						"*": { action_: ["output", "r="], nextState: "r" },
					},
					"+": {
						o: { action_: "d= kv", nextState: "d" },
						"d|D": { action_: "d=", nextState: "d" },
						q: { action_: "d=", nextState: "qd" },
						"qd|qD": { action_: "d=", nextState: "qd" },
						dq: { action_: ["output", "d="], nextState: "d" },
						3: { action_: ["sb=false", "output", "operator"], nextState: "0" },
					},
					amount: { "0|2": { action_: "a=", nextState: "a" } },
					"pm-operator": {
						"0|1|2|a|as": {
							action_: [
								"sb=false",
								"output",
								{ type_: "operator", option: "\\pm" },
							],
							nextState: "0",
						},
					},
					operator: {
						"0|1|2|a|as": {
							action_: ["sb=false", "output", "operator"],
							nextState: "0",
						},
					},
					"-$": {
						"o|q": { action_: ["charge or bond", "output"], nextState: "qd" },
						d: { action_: "d=", nextState: "d" },
						D: {
							action_: ["output", { type_: "bond", option: "-" }],
							nextState: "3",
						},
						q: { action_: "d=", nextState: "qd" },
						qd: { action_: "d=", nextState: "qd" },
						"qD|dq": {
							action_: ["output", { type_: "bond", option: "-" }],
							nextState: "3",
						},
					},
					"-9": {
						"3|o": {
							action_: ["output", { type_: "insert", option: "hyphen" }],
							nextState: "3",
						},
					},
					"- orbital overlap": {
						o: {
							action_: ["output", { type_: "insert", option: "hyphen" }],
							nextState: "2",
						},
						d: {
							action_: ["output", { type_: "insert", option: "hyphen" }],
							nextState: "2",
						},
					},
					"-": {
						"0|1|2": {
							action_: [
								{ type_: "output", option: 1 },
								"beginsWithBond=true",
								{ type_: "bond", option: "-" },
							],
							nextState: "3",
						},
						3: { action_: { type_: "bond", option: "-" } },
						a: {
							action_: ["output", { type_: "insert", option: "hyphen" }],
							nextState: "2",
						},
						as: {
							action_: [
								{ type_: "output", option: 2 },
								{ type_: "bond", option: "-" },
							],
							nextState: "3",
						},
						b: { action_: "b=" },
						o: {
							action_: { type_: "- after o/d", option: !1 },
							nextState: "2",
						},
						q: {
							action_: { type_: "- after o/d", option: !1 },
							nextState: "2",
						},
						"d|qd|dq": {
							action_: { type_: "- after o/d", option: !0 },
							nextState: "2",
						},
						"D|qD|p": {
							action_: ["output", { type_: "bond", option: "-" }],
							nextState: "3",
						},
					},
					amount2: { "1|3": { action_: "a=", nextState: "a" } },
					letters: {
						"0|1|2|3|a|as|b|p|bp|o": { action_: "o=", nextState: "o" },
						"q|dq": { action_: ["output", "o="], nextState: "o" },
						"d|D|qd|qD": { action_: "o after d", nextState: "o" },
					},
					digits: {
						o: { action_: "q=", nextState: "q" },
						"d|D": { action_: "q=", nextState: "dq" },
						q: { action_: ["output", "o="], nextState: "o" },
						a: { action_: "o=", nextState: "o" },
					},
					"space A": { "b|p|bp": {} },
					space: {
						a: { nextState: "as" },
						0: { action_: "sb=false" },
						"1|2": { action_: "sb=true" },
						"r|rt|rd|rdt|rdq": { action_: "output", nextState: "0" },
						"*": { action_: ["output", "sb=true"], nextState: "1" },
					},
					"1st-level escape": {
						"1|2": {
							action_: [
								"output",
								{ type_: "insert+p1", option: "1st-level escape" },
							],
						},
						"*": {
							action_: [
								"output",
								{ type_: "insert+p1", option: "1st-level escape" },
							],
							nextState: "0",
						},
					},
					"[(...)]": {
						"r|rt": { action_: "rd=", nextState: "rd" },
						"rd|rdt": { action_: "rq=", nextState: "rdq" },
					},
					"...": {
						"o|d|D|dq|qd|qD": {
							action_: ["output", { type_: "bond", option: "..." }],
							nextState: "3",
						},
						"*": {
							action_: [
								{ type_: "output", option: 1 },
								{ type_: "insert", option: "ellipsis" },
							],
							nextState: "1",
						},
					},
					". |* ": {
						"*": {
							action_: [
								"output",
								{ type_: "insert", option: "addition compound" },
							],
							nextState: "1",
						},
					},
					"state of aggregation $": {
						"*": {
							action_: ["output", "state of aggregation"],
							nextState: "1",
						},
					},
					"{[(": {
						"a|as|o": {
							action_: ["o=", "output", "parenthesisLevel++"],
							nextState: "2",
						},
						"0|1|2|3": {
							action_: ["o=", "output", "parenthesisLevel++"],
							nextState: "2",
						},
						"*": {
							action_: ["output", "o=", "output", "parenthesisLevel++"],
							nextState: "2",
						},
					},
					")]}": {
						"0|1|2|3|b|p|bp|o": {
							action_: ["o=", "parenthesisLevel--"],
							nextState: "o",
						},
						"a|as|d|D|q|qd|qD|dq": {
							action_: ["output", "o=", "parenthesisLevel--"],
							nextState: "o",
						},
					},
					", ": { "*": { action_: ["output", "comma"], nextState: "0" } },
					"^_": { "*": {} },
					"^{(...)}|^($...$)": {
						"0|1|2|as": { action_: "b=", nextState: "b" },
						p: { action_: "b=", nextState: "bp" },
						"3|o": { action_: "d= kv", nextState: "D" },
						q: { action_: "d=", nextState: "qD" },
						"d|D|qd|qD|dq": { action_: ["output", "d="], nextState: "D" },
					},
					"^a|^\\x{}{}|^\\x{}|^\\x|'": {
						"0|1|2|as": { action_: "b=", nextState: "b" },
						p: { action_: "b=", nextState: "bp" },
						"3|o": { action_: "d= kv", nextState: "d" },
						q: { action_: "d=", nextState: "qd" },
						"d|qd|D|qD": { action_: "d=" },
						dq: { action_: ["output", "d="], nextState: "d" },
					},
					"_{(state of aggregation)}$": {
						"d|D|q|qd|qD|dq": { action_: ["output", "q="], nextState: "q" },
					},
					"_{(...)}|_($...$)|_9|_\\x{}{}|_\\x{}|_\\x": {
						"0|1|2|as": { action_: "p=", nextState: "p" },
						b: { action_: "p=", nextState: "bp" },
						"3|o": { action_: "q=", nextState: "q" },
						"d|D": { action_: "q=", nextState: "dq" },
						"q|qd|qD|dq": { action_: ["output", "q="], nextState: "q" },
					},
					"=<>": {
						"0|1|2|3|a|as|o|q|d|D|qd|qD|dq": {
							action_: [{ type_: "output", option: 2 }, "bond"],
							nextState: "3",
						},
					},
					"#": {
						"0|1|2|3|a|as|o": {
							action_: [
								{ type_: "output", option: 2 },
								{ type_: "bond", option: "#" },
							],
							nextState: "3",
						},
					},
					"{}": {
						"*": { action_: { type_: "output", option: 1 }, nextState: "1" },
					},
					"{...}": {
						"0|1|2|3|a|as|b|p|bp": { action_: "o=", nextState: "o" },
						"o|d|D|q|qd|qD|dq": { action_: ["output", "o="], nextState: "o" },
					},
					"$...$": {
						a: { action_: "a=" },
						"0|1|2|3|as|b|p|bp|o": { action_: "o=", nextState: "o" },
						"as|o": { action_: "o=" },
						"q|d|D|qd|qD|dq": { action_: ["output", "o="], nextState: "o" },
					},
					"\\bond{(...)}": {
						"*": {
							action_: [{ type_: "output", option: 2 }, "bond"],
							nextState: "3",
						},
					},
					"\\frac{(...)}": {
						"*": {
							action_: [{ type_: "output", option: 1 }, "frac-output"],
							nextState: "3",
						},
					},
					"\\overset{(...)}": {
						"*": {
							action_: [{ type_: "output", option: 2 }, "overset-output"],
							nextState: "3",
						},
					},
					"\\underset{(...)}": {
						"*": {
							action_: [{ type_: "output", option: 2 }, "underset-output"],
							nextState: "3",
						},
					},
					"\\underbrace{(...)}": {
						"*": {
							action_: [{ type_: "output", option: 2 }, "underbrace-output"],
							nextState: "3",
						},
					},
					"\\color{(...)}{(...)}1|\\color(...){(...)}2": {
						"*": {
							action_: [{ type_: "output", option: 2 }, "color-output"],
							nextState: "3",
						},
					},
					"\\color{(...)}0": {
						"*": { action_: [{ type_: "output", option: 2 }, "color0-output"] },
					},
					"\\ce{(...)}": {
						"*": {
							action_: [{ type_: "output", option: 2 }, "ce"],
							nextState: "3",
						},
					},
					"\\,": {
						"*": {
							action_: [{ type_: "output", option: 1 }, "copy"],
							nextState: "1",
						},
					},
					"\\x{}{}|\\x{}|\\x": {
						"0|1|2|3|a|as|b|p|bp|o|c0": {
							action_: ["o=", "output"],
							nextState: "3",
						},
						"*": { action_: ["output", "o=", "output"], nextState: "3" },
					},
					others: {
						"*": {
							action_: [{ type_: "output", option: 1 }, "copy"],
							nextState: "3",
						},
					},
					else2: {
						a: { action_: "a to o", nextState: "o", revisit: !0 },
						as: { action_: ["output", "sb=true"], nextState: "1", revisit: !0 },
						"r|rt|rd|rdt|rdq": {
							action_: ["output"],
							nextState: "0",
							revisit: !0,
						},
						"*": { action_: ["output", "copy"], nextState: "3" },
					},
				}),
				actions: {
					"o after d": function (t, e) {
						var a;
						if ((t.d || "").match(/^[0-9]+$/)) {
							var o = t.d;
							(t.d = void 0), (a = this.output(t)), (t.b = o);
						} else a = this.output(t);
						return n.actions["o="](t, e), a;
					},
					"d= kv": function (t, e) {
						(t.d = e), (t.dType = "kv");
					},
					"charge or bond": function (t, e) {
						if (t.beginsWithBond) {
							var a = [];
							return (
								n.concatArray(a, this.output(t)),
								n.concatArray(a, n.actions.bond(t, e, "-")),
								a
							);
						}
						t.d = e;
					},
					"- after o/d": function (t, e, a) {
						var o = n.patterns.match_("orbital", t.o || ""),
							r = n.patterns.match_("one lowercase greek letter $", t.o || ""),
							i = n.patterns.match_("one lowercase latin letter $", t.o || ""),
							c = n.patterns.match_(
								"$one lowercase latin letter$ $",
								t.o || "",
							),
							u = "-" === e && ((o && "" === o.remainder) || r || i || c);
						!u ||
							t.a ||
							t.b ||
							t.p ||
							t.d ||
							t.q ||
							o ||
							!i ||
							(t.o = "$" + t.o + "$");
						var p = [];
						return (
							u
								? (n.concatArray(p, this.output(t)),
									p.push({ type_: "hyphen" }))
								: ((o = n.patterns.match_("digits", t.d || "")),
									a && o && "" === o.remainder
										? (n.concatArray(p, n.actions["d="](t, e)),
											n.concatArray(p, this.output(t)))
										: (n.concatArray(p, this.output(t)),
											n.concatArray(p, n.actions.bond(t, e, "-")))),
							p
						);
					},
					"a to o": function (t) {
						(t.o = t.a), (t.a = void 0);
					},
					"sb=true": function (t) {
						t.sb = !0;
					},
					"sb=false": function (t) {
						t.sb = !1;
					},
					"beginsWithBond=true": function (t) {
						t.beginsWithBond = !0;
					},
					"beginsWithBond=false": function (t) {
						t.beginsWithBond = !1;
					},
					"parenthesisLevel++": function (t) {
						t.parenthesisLevel++;
					},
					"parenthesisLevel--": function (t) {
						t.parenthesisLevel--;
					},
					"state of aggregation": function (t, e) {
						return { type_: "state of aggregation", p1: n.go(e, "o") };
					},
					comma: function (t, e) {
						var a = e.replace(/\s*$/, "");
						return a !== e && 0 === t.parenthesisLevel
							? { type_: "comma enumeration L", p1: a }
							: { type_: "comma enumeration M", p1: a };
					},
					output: function (t, e, a) {
						var o, r, i;
						t.r
							? ((r =
									"M" === t.rdt
										? n.go(t.rd, "tex-math")
										: "T" === t.rdt
											? [{ type_: "text", p1: t.rd || "" }]
											: n.go(t.rd)),
								(i =
									"M" === t.rqt
										? n.go(t.rq, "tex-math")
										: "T" === t.rqt
											? [{ type_: "text", p1: t.rq || "" }]
											: n.go(t.rq)),
								(o = { type_: "arrow", r: t.r, rd: r, rq: i }))
							: ((o = []),
								(t.a || t.b || t.p || t.o || t.q || t.d || a) &&
									(t.sb && o.push({ type_: "entitySkip" }),
									t.o || t.q || t.d || t.b || t.p || 2 === a
										? t.o || t.q || t.d || (!t.b && !t.p)
											? t.o &&
												"kv" === t.dType &&
												n.patterns.match_("d-oxidation$", t.d || "")
												? (t.dType = "oxidation")
												: t.o && "kv" === t.dType && !t.q && (t.dType = void 0)
											: ((t.o = t.a),
												(t.d = t.b),
												(t.q = t.p),
												(t.a = t.b = t.p = void 0))
										: ((t.o = t.a), (t.a = void 0)),
									o.push({
										type_: "chemfive",
										a: n.go(t.a, "a"),
										b: n.go(t.b, "bd"),
										p: n.go(t.p, "pq"),
										o: n.go(t.o, "o"),
										q: n.go(t.q, "pq"),
										d: n.go(t.d, "oxidation" === t.dType ? "oxidation" : "bd"),
										dType: t.dType,
									})));
						for (var c in t)
							"parenthesisLevel" !== c && "beginsWithBond" !== c && delete t[c];
						return o;
					},
					"oxidation-output": function (t, e) {
						var a = ["{"];
						return n.concatArray(a, n.go(e, "oxidation")), a.push("}"), a;
					},
					"frac-output": function (t, e) {
						return { type_: "frac-ce", p1: n.go(e[0]), p2: n.go(e[1]) };
					},
					"overset-output": function (t, e) {
						return { type_: "overset", p1: n.go(e[0]), p2: n.go(e[1]) };
					},
					"underset-output": function (t, e) {
						return { type_: "underset", p1: n.go(e[0]), p2: n.go(e[1]) };
					},
					"underbrace-output": function (t, e) {
						return { type_: "underbrace", p1: n.go(e[0]), p2: n.go(e[1]) };
					},
					"color-output": function (t, e) {
						return { type_: "color", color1: e[0], color2: n.go(e[1]) };
					},
					"r=": function (t, e) {
						t.r = e;
					},
					"rdt=": function (t, e) {
						t.rdt = e;
					},
					"rd=": function (t, e) {
						t.rd = e;
					},
					"rqt=": function (t, e) {
						t.rqt = e;
					},
					"rq=": function (t, e) {
						t.rq = e;
					},
					operator: function (t, e, a) {
						return { type_: "operator", kind_: a || e };
					},
				},
			},
			a: {
				transitions: n.createTransitions({
					empty: { "*": {} },
					"1/2$": { 0: { action_: "1/2" } },
					else: { 0: { nextState: "1", revisit: !0 } },
					"$(...)$": { "*": { action_: "tex-math tight", nextState: "1" } },
					",": {
						"*": { action_: { type_: "insert", option: "commaDecimal" } },
					},
					else2: { "*": { action_: "copy" } },
				}),
				actions: {},
			},
			o: {
				transitions: n.createTransitions({
					empty: { "*": {} },
					"1/2$": { 0: { action_: "1/2" } },
					else: { 0: { nextState: "1", revisit: !0 } },
					letters: { "*": { action_: "rm" } },
					"\\ca": { "*": { action_: { type_: "insert", option: "circa" } } },
					"\\x{}{}|\\x{}|\\x": { "*": { action_: "copy" } },
					"${(...)}$|$(...)$": { "*": { action_: "tex-math" } },
					"{(...)}": { "*": { action_: "{text}" } },
					else2: { "*": { action_: "copy" } },
				}),
				actions: {},
			},
			text: {
				transitions: n.createTransitions({
					empty: { "*": { action_: "output" } },
					"{...}": { "*": { action_: "text=" } },
					"${(...)}$|$(...)$": { "*": { action_: "tex-math" } },
					"\\greek": { "*": { action_: ["output", "rm"] } },
					"\\,|\\x{}{}|\\x{}|\\x": { "*": { action_: ["output", "copy"] } },
					else: { "*": { action_: "text=" } },
				}),
				actions: {
					output: function (t) {
						if (t.text_) {
							var e = { type_: "text", p1: t.text_ };
							for (var a in t) delete t[a];
							return e;
						}
					},
				},
			},
			pq: {
				transitions: n.createTransitions({
					empty: { "*": {} },
					"state of aggregation $": {
						"*": { action_: "state of aggregation" },
					},
					i$: { 0: { nextState: "!f", revisit: !0 } },
					"(KV letters),": { 0: { action_: "rm", nextState: "0" } },
					formula$: { 0: { nextState: "f", revisit: !0 } },
					"1/2$": { 0: { action_: "1/2" } },
					else: { 0: { nextState: "!f", revisit: !0 } },
					"${(...)}$|$(...)$": { "*": { action_: "tex-math" } },
					"{(...)}": { "*": { action_: "text" } },
					"a-z": { f: { action_: "tex-math" } },
					letters: { "*": { action_: "rm" } },
					"-9.,9": { "*": { action_: "9,9" } },
					",": {
						"*": {
							action_: { type_: "insert+p1", option: "comma enumeration S" },
						},
					},
					"\\color{(...)}{(...)}1|\\color(...){(...)}2": {
						"*": { action_: "color-output" },
					},
					"\\color{(...)}0": { "*": { action_: "color0-output" } },
					"\\ce{(...)}": { "*": { action_: "ce" } },
					"\\,|\\x{}{}|\\x{}|\\x": { "*": { action_: "copy" } },
					else2: { "*": { action_: "copy" } },
				}),
				actions: {
					"state of aggregation": function (t, e) {
						return {
							type_: "state of aggregation subscript",
							p1: n.go(e, "o"),
						};
					},
					"color-output": function (t, e) {
						return { type_: "color", color1: e[0], color2: n.go(e[1], "pq") };
					},
				},
			},
			bd: {
				transitions: n.createTransitions({
					empty: { "*": {} },
					x$: { 0: { nextState: "!f", revisit: !0 } },
					formula$: { 0: { nextState: "f", revisit: !0 } },
					else: { 0: { nextState: "!f", revisit: !0 } },
					"-9.,9 no missing 0": { "*": { action_: "9,9" } },
					".": {
						"*": { action_: { type_: "insert", option: "electron dot" } },
					},
					"a-z": { f: { action_: "tex-math" } },
					x: { "*": { action_: { type_: "insert", option: "KV x" } } },
					letters: { "*": { action_: "rm" } },
					"'": { "*": { action_: { type_: "insert", option: "prime" } } },
					"${(...)}$|$(...)$": { "*": { action_: "tex-math" } },
					"{(...)}": { "*": { action_: "text" } },
					"\\color{(...)}{(...)}1|\\color(...){(...)}2": {
						"*": { action_: "color-output" },
					},
					"\\color{(...)}0": { "*": { action_: "color0-output" } },
					"\\ce{(...)}": { "*": { action_: "ce" } },
					"\\,|\\x{}{}|\\x{}|\\x": { "*": { action_: "copy" } },
					else2: { "*": { action_: "copy" } },
				}),
				actions: {
					"color-output": function (t, e) {
						return { type_: "color", color1: e[0], color2: n.go(e[1], "bd") };
					},
				},
			},
			oxidation: {
				transitions: n.createTransitions({
					empty: { "*": {} },
					"roman numeral": { "*": { action_: "roman-numeral" } },
					"${(...)}$|$(...)$": { "*": { action_: "tex-math" } },
					else: { "*": { action_: "copy" } },
				}),
				actions: {
					"roman-numeral": function (t, e) {
						return { type_: "roman numeral", p1: e || "" };
					},
				},
			},
			"tex-math": {
				transitions: n.createTransitions({
					empty: { "*": { action_: "output" } },
					"\\ce{(...)}": { "*": { action_: ["output", "ce"] } },
					"{...}|\\,|\\x{}{}|\\x{}|\\x": { "*": { action_: "o=" } },
					else: { "*": { action_: "o=" } },
				}),
				actions: {
					output: function (t) {
						if (t.o) {
							var e = { type_: "tex-math", p1: t.o };
							for (var a in t) delete t[a];
							return e;
						}
					},
				},
			},
			"tex-math tight": {
				transitions: n.createTransitions({
					empty: { "*": { action_: "output" } },
					"\\ce{(...)}": { "*": { action_: ["output", "ce"] } },
					"{...}|\\,|\\x{}{}|\\x{}|\\x": { "*": { action_: "o=" } },
					"-|+": { "*": { action_: "tight operator" } },
					else: { "*": { action_: "o=" } },
				}),
				actions: {
					"tight operator": function (t, e) {
						t.o = (t.o || "") + "{" + e + "}";
					},
					output: function (t) {
						if (t.o) {
							var e = { type_: "tex-math", p1: t.o };
							for (var a in t) delete t[a];
							return e;
						}
					},
				},
			},
			"9,9": {
				transitions: n.createTransitions({
					empty: { "*": {} },
					",": { "*": { action_: "comma" } },
					else: { "*": { action_: "copy" } },
				}),
				actions: {
					comma: function () {
						return { type_: "commaDecimal" };
					},
				},
			},
			pu: {
				transitions: n.createTransitions({
					empty: { "*": { action_: "output" } },
					space$: { "*": { action_: ["output", "space"] } },
					"{[(|)]}": { "0|a": { action_: "copy" } },
					"(-)(9)^(-9)": { 0: { action_: "number^", nextState: "a" } },
					"(-)(9.,9)(e)(99)": { 0: { action_: "enumber", nextState: "a" } },
					space: { "0|a": {} },
					"pm-operator": {
						"0|a": {
							action_: { type_: "operator", option: "\\pm" },
							nextState: "0",
						},
					},
					operator: { "0|a": { action_: "copy", nextState: "0" } },
					"//": { d: { action_: "o=", nextState: "/" } },
					"/": { d: { action_: "o=", nextState: "/" } },
					"{...}|else": {
						"0|d": { action_: "d=", nextState: "d" },
						a: { action_: ["space", "d="], nextState: "d" },
						"/|q": { action_: "q=", nextState: "q" },
					},
				}),
				actions: {
					enumber: function (t, e) {
						var a = [];
						return (
							"+-" === e[0] || "+/-" === e[0]
								? a.push("\\pm ")
								: e[0] && a.push(e[0]),
							e[1] &&
								(n.concatArray(a, n.go(e[1], "pu-9,9")),
								e[2] &&
									(e[2].match(/[,.]/)
										? n.concatArray(a, n.go(e[2], "pu-9,9"))
										: a.push(e[2])),
								(e[3] = e[4] || e[3]),
								e[3] &&
									((e[3] = e[3].trim()),
									"e" === e[3] || "*" === e[3].substr(0, 1)
										? a.push({ type_: "cdot" })
										: a.push({ type_: "times" }))),
							e[3] && a.push("10^{" + e[5] + "}"),
							a
						);
					},
					"number^": function (t, e) {
						var a = [];
						return (
							"+-" === e[0] || "+/-" === e[0]
								? a.push("\\pm ")
								: e[0] && a.push(e[0]),
							n.concatArray(a, n.go(e[1], "pu-9,9")),
							a.push("^{" + e[2] + "}"),
							a
						);
					},
					operator: function (t, e, a) {
						return { type_: "operator", kind_: a || e };
					},
					space: function () {
						return { type_: "pu-space-1" };
					},
					output: function (t) {
						var e,
							a = n.patterns.match_("{(...)}", t.d || "");
						a && "" === a.remainder && (t.d = a.match_);
						var o = n.patterns.match_("{(...)}", t.q || "");
						if (
							(o && "" === o.remainder && (t.q = o.match_),
							t.d &&
								((t.d = t.d.replace(/\u00B0C|\^oC|\^{o}C/g, "{}^{\\circ}C")),
								(t.d = t.d.replace(/\u00B0F|\^oF|\^{o}F/g, "{}^{\\circ}F"))),
							t.q)
						) {
							(t.q = t.q.replace(/\u00B0C|\^oC|\^{o}C/g, "{}^{\\circ}C")),
								(t.q = t.q.replace(/\u00B0F|\^oF|\^{o}F/g, "{}^{\\circ}F"));
							var r = { d: n.go(t.d, "pu"), q: n.go(t.q, "pu") };
							"//" === t.o
								? (e = { type_: "pu-frac", p1: r.d, p2: r.q })
								: ((e = r.d),
									r.d.length > 1 || r.q.length > 1
										? e.push({ type_: " / " })
										: e.push({ type_: "/" }),
									n.concatArray(e, r.q));
						} else e = n.go(t.d, "pu-2");
						for (var i in t) delete t[i];
						return e;
					},
				},
			},
			"pu-2": {
				transitions: n.createTransitions({
					empty: { "*": { action_: "output" } },
					"*": { "*": { action_: ["output", "cdot"], nextState: "0" } },
					"\\x": { "*": { action_: "rm=" } },
					space: { "*": { action_: ["output", "space"], nextState: "0" } },
					"^{(...)}|^(-1)": { 1: { action_: "^(-1)" } },
					"-9.,9": {
						0: { action_: "rm=", nextState: "0" },
						1: { action_: "^(-1)", nextState: "0" },
					},
					"{...}|else": { "*": { action_: "rm=", nextState: "1" } },
				}),
				actions: {
					cdot: function () {
						return { type_: "tight cdot" };
					},
					"^(-1)": function (t, e) {
						t.rm += "^{" + e + "}";
					},
					space: function () {
						return { type_: "pu-space-2" };
					},
					output: function (t) {
						var e = [];
						if (t.rm) {
							var a = n.patterns.match_("{(...)}", t.rm || "");
							e =
								a && "" === a.remainder
									? n.go(a.match_, "pu")
									: { type_: "rm", p1: t.rm };
						}
						for (var o in t) delete t[o];
						return e;
					},
				},
			},
			"pu-9,9": {
				transitions: n.createTransitions({
					empty: { 0: { action_: "output-0" }, o: { action_: "output-o" } },
					",": { 0: { action_: ["output-0", "comma"], nextState: "o" } },
					".": { 0: { action_: ["output-0", "copy"], nextState: "o" } },
					else: { "*": { action_: "text=" } },
				}),
				actions: {
					comma: function () {
						return { type_: "commaDecimal" };
					},
					"output-0": function (t) {
						var e = [];
						if (((t.text_ = t.text_ || ""), t.text_.length > 4)) {
							var a = t.text_.length % 3;
							0 === a && (a = 3);
							for (var n = t.text_.length - 3; n > 0; n -= 3)
								e.push(t.text_.substr(n, 3)),
									e.push({ type_: "1000 separator" });
							e.push(t.text_.substr(0, a)), e.reverse();
						} else e.push(t.text_);
						for (var o in t) delete t[o];
						return e;
					},
					"output-o": function (t) {
						var e = [];
						if (((t.text_ = t.text_ || ""), t.text_.length > 4)) {
							for (var a = t.text_.length - 3, n = 0; n < a; n += 3)
								e.push(t.text_.substr(n, 3)),
									e.push({ type_: "1000 separator" });
							e.push(t.text_.substr(n));
						} else e.push(t.text_);
						for (var o in t) delete t[o];
						return e;
					},
				},
			},
		};
		var o = {
			go: function (t, e) {
				if (!t) return "";
				for (var a = "", n = !1, r = 0; r < t.length; r++) {
					var i = t[r];
					"string" == typeof i
						? (a += i)
						: ((a += o._go2(i)), "1st-level escape" === i.type_ && (n = !0));
				}
				return e || n || !a || (a = "{" + a + "}"), a;
			},
			_goInner: function (t) {
				return t ? o.go(t, !0) : t;
			},
			_go2: function (t) {
				var e;
				switch (t.type_) {
					case "chemfive":
						e = "";
						var a = {
							a: o._goInner(t.a),
							b: o._goInner(t.b),
							p: o._goInner(t.p),
							o: o._goInner(t.o),
							q: o._goInner(t.q),
							d: o._goInner(t.d),
						};
						a.a &&
							(a.a.match(/^[+\-]/) && (a.a = "{" + a.a + "}"),
							(e += a.a + "\\,")),
							(a.b || a.p) &&
								((e += "{\\vphantom{X}}"),
								(e +=
									"^{\\hphantom{" +
									(a.b || "") +
									"}}_{\\hphantom{" +
									(a.p || "") +
									"}}"),
								(e += "{\\vphantom{X}}"),
								(e +=
									"^{\\smash[t]{\\vphantom{2}}\\llap{" + (a.b || "") + "}}"),
								(e +=
									"_{\\vphantom{2}\\llap{\\smash[t]{" + (a.p || "") + "}}}")),
							a.o &&
								(a.o.match(/^[+\-]/) && (a.o = "{" + a.o + "}"), (e += a.o)),
							"kv" === t.dType
								? ((a.d || a.q) && (e += "{\\vphantom{X}}"),
									a.d && (e += "^{" + a.d + "}"),
									a.q && (e += "_{\\smash[t]{" + a.q + "}}"))
								: "oxidation" === t.dType
									? (a.d && ((e += "{\\vphantom{X}}"), (e += "^{" + a.d + "}")),
										a.q &&
											((e += "{\\vphantom{X}}"),
											(e += "_{\\smash[t]{" + a.q + "}}")))
									: (a.q &&
											((e += "{\\vphantom{X}}"),
											(e += "_{\\smash[t]{" + a.q + "}}")),
										a.d && ((e += "{\\vphantom{X}}"), (e += "^{" + a.d + "}")));
						break;
					case "rm":
						e = "\\mathrm{" + t.p1 + "}";
						break;
					case "text":
						t.p1.match(/[\^_]/)
							? ((t.p1 = t.p1.replace(" ", "~").replace("-", "\\text{-}")),
								(e = "\\mathrm{" + t.p1 + "}"))
							: (e = "\\text{" + t.p1 + "}");
						break;
					case "roman numeral":
						e = "\\mathrm{" + t.p1 + "}";
						break;
					case "state of aggregation":
						e = "\\mskip2mu " + o._goInner(t.p1);
						break;
					case "state of aggregation subscript":
						e = "\\mskip1mu " + o._goInner(t.p1);
						break;
					case "bond":
						if (!(e = o._getBond(t.kind_)))
							throw [
								"MhchemErrorBond",
								"mhchem Error. Unknown bond type (" + t.kind_ + ")",
							];
						break;
					case "frac":
						var n = "\\frac{" + t.p1 + "}{" + t.p2 + "}";
						e =
							"\\mathchoice{\\textstyle" +
							n +
							"}{" +
							n +
							"}{" +
							n +
							"}{" +
							n +
							"}";
						break;
					case "pu-frac":
						var r =
							"\\frac{" + o._goInner(t.p1) + "}{" + o._goInner(t.p2) + "}";
						e =
							"\\mathchoice{\\textstyle" +
							r +
							"}{" +
							r +
							"}{" +
							r +
							"}{" +
							r +
							"}";
						break;
					case "tex-math":
						e = t.p1 + " ";
						break;
					case "frac-ce":
						e = "\\frac{" + o._goInner(t.p1) + "}{" + o._goInner(t.p2) + "}";
						break;
					case "overset":
						e = "\\overset{" + o._goInner(t.p1) + "}{" + o._goInner(t.p2) + "}";
						break;
					case "underset":
						e =
							"\\underset{" + o._goInner(t.p1) + "}{" + o._goInner(t.p2) + "}";
						break;
					case "underbrace":
						e =
							"\\underbrace{" +
							o._goInner(t.p1) +
							"}_{" +
							o._goInner(t.p2) +
							"}";
						break;
					case "color":
						e = "{\\color{" + t.color1 + "}{" + o._goInner(t.color2) + "}}";
						break;
					case "color0":
						e = "\\color{" + t.color + "}";
						break;
					case "arrow":
						var i = { rd: o._goInner(t.rd), rq: o._goInner(t.rq) },
							c = o._getArrow(t.r);
						i.rd || i.rq
							? "<=>" === t.r ||
								"<=>>" === t.r ||
								"<<=>" === t.r ||
								"<--\x3e" === t.r
								? ((c = "\\long" + c),
									i.rd && (c = "\\overset{" + i.rd + "}{" + c + "}"),
									i.rq &&
										(c = "\\underset{\\lower7mu{" + i.rq + "}}{" + c + "}"),
									(c = " {}\\mathrel{" + c + "}{} "))
								: (i.rq && (c += "[{" + i.rq + "}]"),
									(c = " {}\\mathrel{\\x" + (c += "{" + i.rd + "}") + "}{} "))
							: (c = " {}\\mathrel{\\long" + c + "}{} "),
							(e = c);
						break;
					case "operator":
						e = o._getOperator(t.kind_);
						break;
					case "1st-level escape":
						e = t.p1 + " ";
						break;
					case "space":
						e = " ";
						break;
					case "entitySkip":
					case "pu-space-1":
						e = "~";
						break;
					case "pu-space-2":
						e = "\\mkern3mu ";
						break;
					case "1000 separator":
						e = "\\mkern2mu ";
						break;
					case "commaDecimal":
						e = "{,}";
						break;
					case "comma enumeration L":
						e = "{" + t.p1 + "}\\mkern6mu ";
						break;
					case "comma enumeration M":
						e = "{" + t.p1 + "}\\mkern3mu ";
						break;
					case "comma enumeration S":
						e = "{" + t.p1 + "}\\mkern1mu ";
						break;
					case "hyphen":
						e = "\\text{-}";
						break;
					case "addition compound":
						e = "\\,{\\cdot}\\,";
						break;
					case "electron dot":
						e = "\\mkern1mu \\bullet\\mkern1mu ";
						break;
					case "KV x":
						e = "{\\times}";
						break;
					case "prime":
						e = "\\prime ";
						break;
					case "cdot":
						e = "\\cdot ";
						break;
					case "tight cdot":
						e = "\\mkern1mu{\\cdot}\\mkern1mu ";
						break;
					case "times":
						e = "\\times ";
						break;
					case "circa":
						e = "{\\sim}";
						break;
					case "^":
						e = "uparrow";
						break;
					case "v":
						e = "downarrow";
						break;
					case "ellipsis":
						e = "\\ldots ";
						break;
					case "/":
						e = "/";
						break;
					case " / ":
						e = "\\,/\\,";
						break;
					default:
						throw ["MhchemBugT", "mhchem bug T. Please report."];
				}
				return e;
			},
			_getArrow: function (t) {
				switch (t) {
					case "->":
					case "\u2192":
					case "\u27f6":
						return "rightarrow";
					case "<-":
						return "leftarrow";
					case "<->":
						return "leftrightarrow";
					case "<--\x3e":
						return "leftrightarrows";
					case "<=>":
					case "\u21cc":
						return "rightleftharpoons";
					case "<=>>":
						return "Rightleftharpoons";
					case "<<=>":
						return "Leftrightharpoons";
					default:
						throw ["MhchemBugT", "mhchem bug T. Please report."];
				}
			},
			_getBond: function (t) {
				switch (t) {
					case "-":
					case "1":
						return "{-}";
					case "=":
					case "2":
						return "{=}";
					case "#":
					case "3":
						return "{\\equiv}";
					case "~":
						return "{\\tripledash}";
					case "~-":
						return "{\\rlap{\\lower.1em{-}}\\raise.1em{\\tripledash}}";
					case "~=":
					case "~--":
						return "{\\rlap{\\lower.2em{-}}\\rlap{\\raise.2em{\\tripledash}}-}";
					case "-~-":
						return "{\\rlap{\\lower.2em{-}}\\rlap{\\raise.2em{-}}\\tripledash}";
					case "...":
						return "{{\\cdot}{\\cdot}{\\cdot}}";
					case "....":
						return "{{\\cdot}{\\cdot}{\\cdot}{\\cdot}}";
					case "->":
						return "{\\rightarrow}";
					case "<-":
						return "{\\leftarrow}";
					case "<":
						return "{<}";
					case ">":
						return "{>}";
					default:
						throw ["MhchemBugT", "mhchem bug T. Please report."];
				}
			},
			_getOperator: function (t) {
				switch (t) {
					case "+":
						return " {}+{} ";
					case "-":
						return " {}-{} ";
					case "=":
						return " {}={} ";
					case "<":
						return " {}<{} ";
					case ">":
						return " {}>{} ";
					case "<<":
						return " {}\\ll{} ";
					case ">>":
						return " {}\\gg{} ";
					case "\\pm":
						return " {}\\pm{} ";
					case "\\approx":
					case "$\\approx$":
						return " {}\\approx{} ";
					case "v":
					case "(v)":
						return " \\downarrow{} ";
					case "^":
					case "(^)":
						return " \\uparrow{} ";
					default:
						throw ["MhchemBugT", "mhchem bug T. Please report."];
				}
			},
		};
		function r(t) {}
		function i(t) {}
		(e.mhchemParser = n),
			(e.texify = o),
			(e.assertNever = r),
			(e.assertString = i);
	},
	function (t, e, a) {
		"use strict";
		a.r(e);
		var n = a(0),
			o = a(1);
		Object(n.combineWithMathJax)({
			_: { input: { tex: { mhchem: { MhchemConfiguration: o } } } },
		});
	},
]);