!(function (t, e) {
	if ("object" == typeof exports && "object" == typeof module)
		module.exports = e(require("katex"));
	else if ("function" == typeof define && define.amd) define(["katex"], e);
	else {
		var n = "object" == typeof exports ? e(require("katex")) : e(t.katex);
		for (var o in n) ("object" == typeof exports ? exports : t)[o] = n[o];
	}
})("undefined" != typeof self ? self : this, function (t) {
	return (function (t) {
		var e = {};
		function n(o) {
			if (e[o]) return e[o].exports;
			var a = (e[o] = { i: o, l: !1, exports: {} });
			return t[o].call(a.exports, a, a.exports, n), (a.l = !0), a.exports;
		}
		return (
			(n.m = t),
			(n.c = e),
			(n.d = function (t, e, o) {
				n.o(t, e) || Object.defineProperty(t, e, { enumerable: !0, get: o });
			}),
			(n.r = function (t) {
				"undefined" != typeof Symbol &&
					Symbol.toStringTag &&
					Object.defineProperty(t, Symbol.toStringTag, { value: "Module" }),
					Object.defineProperty(t, "__esModule", { value: !0 });
			}),
			(n.t = function (t, e) {
				if ((1 & e && (t = n(t)), 8 & e)) return t;
				if (4 & e && "object" == typeof t && t && t.__esModule) return t;
				var o = Object.create(null);
				if (
					(n.r(o),
					Object.defineProperty(o, "default", { enumerable: !0, value: t }),
					2 & e && "string" != typeof t)
				)
					for (var a in t)
						n.d(
							o,
							a,
							function (e) {
								return t[e];
							}.bind(null, a),
						);
				return o;
			}),
			(n.n = function (t) {
				var e =
					t && t.__esModule
						? function () {
								return t.default;
							}
						: function () {
								return t;
							};
				return n.d(e, "a", e), e;
			}),
			(n.o = function (t, e) {
				return Object.prototype.hasOwnProperty.call(t, e);
			}),
			(n.p = ""),
			n((n.s = 1))
		);
	})([
		function (e, n) {
			e.exports = t;
		},
		function (t, e, n) {
			"use strict";
			n.r(e);
			var o = n(0),
				a = n.n(o);
			a.a.__defineMacro("\\ce", function (t) {
				return r(t.consumeArgs(1)[0], "ce");
			}),
				a.a.__defineMacro("\\pu", function (t) {
					return r(t.consumeArgs(1)[0], "pu");
				}),
				a.a.__defineMacro(
					"\\tripledash",
					"{\\vphantom{-}\\raisebox{2.56mu}{$\\mkern2mu\\tiny\\text{-}\\mkern1mu\\text{-}\\mkern1mu\\text{-}\\mkern2mu$}}",
				);
			var r = function (t, e) {
					for (
						var n = "", o = t[t.length - 1].loc.start, a = t.length - 1;
						a >= 0;
						a--
					)
						t[a].loc.start > o && ((n += " "), (o = t[a].loc.start)),
							(n += t[a].text),
							(o += t[a].text.length);
					return c.go(i.go(n, e));
				},
				i = {
					go: function (t, e) {
						if (!t) return [];
						void 0 === e && (e = "ce");
						var n,
							o = "0",
							a = {};
						(a.parenthesisLevel = 0),
							(t = (t = (t = t.replace(/\n/g, " ")).replace(
								/[\u2212\u2013\u2014\u2010]/g,
								"-",
							)).replace(/[\u2026]/g, "..."));
						for (var r = 10, c = []; ; ) {
							n !== t ? ((r = 10), (n = t)) : r--;
							var u = i.stateMachines[e],
								p = u.transitions[o] || u.transitions["*"];
							t: for (var s = 0; s < p.length; s++) {
								var _ = i.patterns.match_(p[s].pattern, t);
								if (_) {
									for (var d = p[s].task, m = 0; m < d.action_.length; m++) {
										var l;
										if (u.actions[d.action_[m].type_])
											l = u.actions[d.action_[m].type_](
												a,
												_.match_,
												d.action_[m].option,
											);
										else {
											if (!i.actions[d.action_[m].type_])
												throw [
													"MhchemBugA",
													"mhchem bug A. Please report. (" +
														d.action_[m].type_ +
														")",
												];
											l = i.actions[d.action_[m].type_](
												a,
												_.match_,
												d.action_[m].option,
											);
										}
										i.concatArray(c, l);
									}
									if (((o = d.nextState || o), !(t.length > 0))) return c;
									if ((d.revisit || (t = _.remainder), !d.toContinue)) break t;
								}
							}
							if (r <= 0) throw ["MhchemBugU", "mhchem bug U. Please report."];
						}
					},
					concatArray: function (t, e) {
						if (e)
							if (Array.isArray(e))
								for (var n = 0; n < e.length; n++) t.push(e[n]);
							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 = i.patterns.findObserveGroups(
									t,
									"",
									/^\([a-z]{1,3}(?=[\),])/,
									")",
									"",
								);
								if (e && e.remainder.match(/^($|[\s,;\)\]\}])/)) return e;
								var n = t.match(/^(?:\((?:\\ca\s?)?\$[amothc]\$\))/);
								return n
									? { match_: n[0], remainder: t.substr(n[0].length) }
									: null;
							},
							"_{(state of aggregation)}$": /^_\{(\([a-z]{1,3}\))\}/,
							"{[(": /^(?:\\\{|\[|\()/,
							")]}": /^(?:\)|\]|\\\})/,
							", ": /^[,;]\s*/,
							",": /^[,;]/,
							".": /^[.]/,
							". ": /^([.\u22C5\u00B7\u2022])\s*/,
							"...": /^\.\.\.(?=$|[^.])/,
							"* ": /^([*])\s*/,
							"^{(...)}": function (t) {
								return i.patterns.findObserveGroups(t, "^{", "", "", "}");
							},
							"^($...$)": function (t) {
								return i.patterns.findObserveGroups(t, "^", "$", "$", "");
							},
							"^a": /^\^([0-9]+|[^\\_])/,
							"^\\x{}{}": function (t) {
								return i.patterns.findObserveGroups(
									t,
									"^",
									/^\\[a-zA-Z]+\{/,
									"}",
									"",
									"",
									"{",
									"}",
									"",
									!0,
								);
							},
							"^\\x{}": function (t) {
								return i.patterns.findObserveGroups(
									t,
									"^",
									/^\\[a-zA-Z]+\{/,
									"}",
									"",
								);
							},
							"^\\x": /^\^(\\[a-zA-Z]+)\s*/,
							"^(-1)": /^\^(-?\d+)/,
							"'": /^'/,
							"_{(...)}": function (t) {
								return i.patterns.findObserveGroups(t, "_{", "", "", "}");
							},
							"_($...$)": function (t) {
								return i.patterns.findObserveGroups(t, "_", "$", "$", "");
							},
							_9: /^_([+\-]?[0-9]+|[^\\])/,
							"_\\x{}{}": function (t) {
								return i.patterns.findObserveGroups(
									t,
									"_",
									/^\\[a-zA-Z]+\{/,
									"}",
									"",
									"",
									"{",
									"}",
									"",
									!0,
								);
							},
							"_\\x{}": function (t) {
								return i.patterns.findObserveGroups(
									t,
									"_",
									/^\\[a-zA-Z]+\{/,
									"}",
									"",
								);
							},
							"_\\x": /^_(\\[a-zA-Z]+)\s*/,
							"^_": /^(?:\^(?=_)|\_(?=\^)|[\^_]$)/,
							"{}": /^\{\}/,
							"{...}": function (t) {
								return i.patterns.findObserveGroups(t, "", "{", "}", "");
							},
							"{(...)}": function (t) {
								return i.patterns.findObserveGroups(t, "{", "", "", "}");
							},
							"$...$": function (t) {
								return i.patterns.findObserveGroups(t, "", "$", "$", "");
							},
							"${(...)}$": function (t) {
								return i.patterns.findObserveGroups(t, "${", "", "", "}$");
							},
							"$(...)$": function (t) {
								return i.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 i.patterns.findObserveGroups(t, "\\bond{", "", "", "}");
							},
							"->": /^(?:<->|<-->|->|<-|<=>>|<<=>|<=>|[\u2192\u27F6\u21CC])/,
							CMT: /^[CMT](?=\[)/,
							"[(...)]": function (t) {
								return i.patterns.findObserveGroups(t, "[", "", "", "]");
							},
							"1st-level escape": /^(&|\\\\|\\hline)\s*/,
							"\\,": /^(?:\\[,\ ;:])/,
							"\\x{}{}": function (t) {
								return i.patterns.findObserveGroups(
									t,
									"",
									/^\\[a-zA-Z]+\{/,
									"}",
									"",
									"",
									"{",
									"}",
									"",
									!0,
								);
							},
							"\\x{}": function (t) {
								return i.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 i.patterns.findObserveGroups(
									t,
									"\\frac{",
									"",
									"",
									"}",
									"{",
									"",
									"",
									"}",
								);
							},
							"\\overset{(...)}": function (t) {
								return i.patterns.findObserveGroups(
									t,
									"\\overset{",
									"",
									"",
									"}",
									"{",
									"",
									"",
									"}",
								);
							},
							"\\underset{(...)}": function (t) {
								return i.patterns.findObserveGroups(
									t,
									"\\underset{",
									"",
									"",
									"}",
									"{",
									"",
									"",
									"}",
								);
							},
							"\\underbrace{(...)}": function (t) {
								return i.patterns.findObserveGroups(
									t,
									"\\underbrace{",
									"",
									"",
									"}_",
									"{",
									"",
									"",
									"}",
								);
							},
							"\\color{(...)}0": function (t) {
								return i.patterns.findObserveGroups(t, "\\color{", "", "", "}");
							},
							"\\color{(...)}{(...)}1": function (t) {
								return i.patterns.findObserveGroups(
									t,
									"\\color{",
									"",
									"",
									"}",
									"{",
									"",
									"",
									"}",
								);
							},
							"\\color(...){(...)}2": function (t) {
								return i.patterns.findObserveGroups(
									t,
									"\\color",
									"\\",
									"",
									/^(?=\{)/,
									"{",
									"",
									"",
									"}",
								);
							},
							"\\ce{(...)}": function (t) {
								return i.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 n = i.patterns.findObserveGroups(t, "", "$", "$", "");
								return n &&
									(e = n.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, n, o, a, r, i, c, u, p) {
							var s = function (t, e) {
									if ("string" == typeof e)
										return 0 !== t.indexOf(e) ? null : e;
									var n = t.match(e);
									return n ? n[0] : null;
								},
								_ = s(t, e);
							if (null === _) return null;
							if (((t = t.substr(_.length)), null === (_ = s(t, n))))
								return null;
							var d = (function (t, e, n) {
								for (var o = 0; e < t.length; ) {
									var a = t.charAt(e),
										r = s(t.substr(e), n);
									if (null !== r && 0 === o)
										return { endMatchBegin: e, endMatchEnd: e + r.length };
									if ("{" === a) o++;
									else if ("}" === a) {
										if (0 === o)
											throw [
												"ExtraCloseMissingOpen",
												"Extra close brace or missing open brace",
											];
										o--;
									}
									e++;
								}
								return null;
							})(t, _.length, o || a);
							if (null === d) return null;
							var m = t.substring(0, o ? d.endMatchEnd : d.endMatchBegin);
							if (r || i) {
								var l = this.findObserveGroups(
									t.substr(d.endMatchEnd),
									r,
									i,
									c,
									u,
								);
								if (null === l) return null;
								var f = [m, l.match_];
								return { match_: p ? f.join("") : f, remainder: l.remainder };
							}
							return { match_: m, remainder: t.substr(d.endMatchEnd) };
						},
						match_: function (t, e) {
							var n = i.patterns.patterns[t];
							if (void 0 === n)
								throw [
									"MhchemBugP",
									"mhchem bug P. Please report. (" + t + ")",
								];
							if ("function" == typeof n) return i.patterns.patterns[t](e);
							var o = e.match(n);
							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, n) {
							return { type_: n };
						},
						"insert+p1": function (t, e, n) {
							return { type_: n, p1: e };
						},
						"insert+p1+p2": function (t, e, n) {
							return { type_: n, 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 i.go(e, "text");
						},
						"{text}": function (t, e) {
							var n = ["{"];
							return i.concatArray(n, i.go(e, "text")), n.push("}"), n;
						},
						"tex-math": function (t, e) {
							return i.go(e, "tex-math");
						},
						"tex-math tight": function (t, e) {
							return i.go(e, "tex-math tight");
						},
						bond: function (t, e, n) {
							return { type_: "bond", kind_: n || e };
						},
						"color0-output": function (t, e) {
							return { type_: "color0", color: e[0] };
						},
						ce: function (t, e) {
							return i.go(e);
						},
						"1/2": function (t, e) {
							var n = [];
							e.match(/^[+\-]/) && (n.push(e.substr(0, 1)), (e = e.substr(1)));
							var o = e.match(
								/^([0-9]+|\$[a-z]\$|[a-z])\/([0-9]+)(\$[a-z]\$|[a-z])?$/,
							);
							return (
								(o[1] = o[1].replace(/\$/g, "")),
								n.push({ type_: "frac", p1: o[1], p2: o[2] }),
								o[3] &&
									((o[3] = o[3].replace(/\$/g, "")),
									n.push({ type_: "tex-math", p1: o[3] })),
								n
							);
						},
						"9,9": function (t, e) {
							return i.go(e, "9,9");
						},
					},
					createTransitions: function (t) {
						var e,
							n,
							o,
							a,
							r = {};
						for (e in t)
							for (n in t[e])
								for (
									o = n.split("|"), t[e][n].stateArray = o, a = 0;
									a < o.length;
									a++
								)
									r[o[a]] = [];
						for (e in t)
							for (n in t[e])
								for (o = t[e][n].stateArray || [], a = 0; a < o.length; a++) {
									var i = t[e][n];
									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 ("*" === o[a])
											for (var s in r) r[s].push({ pattern: u[p], task: i });
										else r[o[a]].push({ pattern: u[p], task: i });
								}
						return r;
					},
					stateMachines: {},
				};
			i.stateMachines = {
				ce: {
					transitions: i.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 n;
							if ((t.d || "").match(/^[0-9]+$/)) {
								var o = t.d;
								(t.d = void 0), (n = this.output(t)), (t.b = o);
							} else n = this.output(t);
							return i.actions["o="](t, e), n;
						},
						"d= kv": function (t, e) {
							(t.d = e), (t.dType = "kv");
						},
						"charge or bond": function (t, e) {
							if (t.beginsWithBond) {
								var n = [];
								return (
									i.concatArray(n, this.output(t)),
									i.concatArray(n, i.actions.bond(t, e, "-")),
									n
								);
							}
							t.d = e;
						},
						"- after o/d": function (t, e, n) {
							var o = i.patterns.match_("orbital", t.o || ""),
								a = i.patterns.match_(
									"one lowercase greek letter $",
									t.o || "",
								),
								r = i.patterns.match_(
									"one lowercase latin letter $",
									t.o || "",
								),
								c = i.patterns.match_(
									"$one lowercase latin letter$ $",
									t.o || "",
								),
								u = "-" === e && ((o && "" === o.remainder) || a || r || c);
							!u ||
								t.a ||
								t.b ||
								t.p ||
								t.d ||
								t.q ||
								o ||
								!r ||
								(t.o = "$" + t.o + "$");
							var p = [];
							return (
								u
									? (i.concatArray(p, this.output(t)),
										p.push({ type_: "hyphen" }))
									: ((o = i.patterns.match_("digits", t.d || "")),
										n && o && "" === o.remainder
											? (i.concatArray(p, i.actions["d="](t, e)),
												i.concatArray(p, this.output(t)))
											: (i.concatArray(p, this.output(t)),
												i.concatArray(p, i.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: i.go(e, "o") };
						},
						comma: function (t, e) {
							var n = e.replace(/\s*$/, "");
							return n !== e && 0 === t.parenthesisLevel
								? { type_: "comma enumeration L", p1: n }
								: { type_: "comma enumeration M", p1: n };
						},
						output: function (t, e, n) {
							var o, a, r;
							t.r
								? ((a =
										"M" === t.rdt
											? i.go(t.rd, "tex-math")
											: "T" === t.rdt
												? [{ type_: "text", p1: t.rd || "" }]
												: i.go(t.rd)),
									(r =
										"M" === t.rqt
											? i.go(t.rq, "tex-math")
											: "T" === t.rqt
												? [{ type_: "text", p1: t.rq || "" }]
												: i.go(t.rq)),
									(o = { type_: "arrow", r: t.r, rd: a, rq: r }))
								: ((o = []),
									(t.a || t.b || t.p || t.o || t.q || t.d || n) &&
										(t.sb && o.push({ type_: "entitySkip" }),
										t.o || t.q || t.d || t.b || t.p || 2 === n
											? t.o || t.q || t.d || (!t.b && !t.p)
												? t.o &&
													"kv" === t.dType &&
													i.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: i.go(t.a, "a"),
											b: i.go(t.b, "bd"),
											p: i.go(t.p, "pq"),
											o: i.go(t.o, "o"),
											q: i.go(t.q, "pq"),
											d: i.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 n = ["{"];
							return i.concatArray(n, i.go(e, "oxidation")), n.push("}"), n;
						},
						"frac-output": function (t, e) {
							return { type_: "frac-ce", p1: i.go(e[0]), p2: i.go(e[1]) };
						},
						"overset-output": function (t, e) {
							return { type_: "overset", p1: i.go(e[0]), p2: i.go(e[1]) };
						},
						"underset-output": function (t, e) {
							return { type_: "underset", p1: i.go(e[0]), p2: i.go(e[1]) };
						},
						"underbrace-output": function (t, e) {
							return { type_: "underbrace", p1: i.go(e[0]), p2: i.go(e[1]) };
						},
						"color-output": function (t, e) {
							return { type_: "color", color1: e[0], color2: i.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, n) {
							return { type_: "operator", kind_: n || e };
						},
					},
				},
				a: {
					transitions: i.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: i.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: i.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 n in t) delete t[n];
								return e;
							}
						},
					},
				},
				pq: {
					transitions: i.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: i.go(e, "o"),
							};
						},
						"color-output": function (t, e) {
							return { type_: "color", color1: e[0], color2: i.go(e[1], "pq") };
						},
					},
				},
				bd: {
					transitions: i.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: i.go(e[1], "bd") };
						},
					},
				},
				oxidation: {
					transitions: i.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: i.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 n in t) delete t[n];
								return e;
							}
						},
					},
				},
				"tex-math tight": {
					transitions: i.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 n in t) delete t[n];
								return e;
							}
						},
					},
				},
				"9,9": {
					transitions: i.createTransitions({
						empty: { "*": {} },
						",": { "*": { action_: "comma" } },
						else: { "*": { action_: "copy" } },
					}),
					actions: {
						comma: function () {
							return { type_: "commaDecimal" };
						},
					},
				},
				pu: {
					transitions: i.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 n = [];
							return (
								"+-" === e[0] || "+/-" === e[0]
									? n.push("\\pm ")
									: e[0] && n.push(e[0]),
								e[1] &&
									(i.concatArray(n, i.go(e[1], "pu-9,9")),
									e[2] &&
										(e[2].match(/[,.]/)
											? i.concatArray(n, i.go(e[2], "pu-9,9"))
											: n.push(e[2])),
									(e[3] = e[4] || e[3]),
									e[3] &&
										((e[3] = e[3].trim()),
										"e" === e[3] || "*" === e[3].substr(0, 1)
											? n.push({ type_: "cdot" })
											: n.push({ type_: "times" }))),
								e[3] && n.push("10^{" + e[5] + "}"),
								n
							);
						},
						"number^": function (t, e) {
							var n = [];
							return (
								"+-" === e[0] || "+/-" === e[0]
									? n.push("\\pm ")
									: e[0] && n.push(e[0]),
								i.concatArray(n, i.go(e[1], "pu-9,9")),
								n.push("^{" + e[2] + "}"),
								n
							);
						},
						operator: function (t, e, n) {
							return { type_: "operator", kind_: n || e };
						},
						space: function () {
							return { type_: "pu-space-1" };
						},
						output: function (t) {
							var e,
								n = i.patterns.match_("{(...)}", t.d || "");
							n && "" === n.remainder && (t.d = n.match_);
							var o = i.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 a = { d: i.go(t.d, "pu"), q: i.go(t.q, "pu") };
								"//" === t.o
									? (e = { type_: "pu-frac", p1: a.d, p2: a.q })
									: ((e = a.d),
										a.d.length > 1 || a.q.length > 1
											? e.push({ type_: " / " })
											: e.push({ type_: "/" }),
										i.concatArray(e, a.q));
							} else e = i.go(t.d, "pu-2");
							for (var r in t) delete t[r];
							return e;
						},
					},
				},
				"pu-2": {
					transitions: i.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 n = i.patterns.match_("{(...)}", t.rm || "");
								e =
									n && "" === n.remainder
										? i.go(n.match_, "pu")
										: { type_: "rm", p1: t.rm };
							}
							for (var o in t) delete t[o];
							return e;
						},
					},
				},
				"pu-9,9": {
					transitions: i.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 n = t.text_.length % 3;
								0 === n && (n = 3);
								for (var o = t.text_.length - 3; o > 0; o -= 3)
									e.push(t.text_.substr(o, 3)),
										e.push({ type_: "1000 separator" });
								e.push(t.text_.substr(0, n)), e.reverse();
							} else e.push(t.text_);
							for (var a in t) delete t[a];
							return e;
						},
						"output-o": function (t) {
							var e = [];
							if (((t.text_ = t.text_ || ""), t.text_.length > 4)) {
								for (var n = t.text_.length - 3, o = 0; o < n; o += 3)
									e.push(t.text_.substr(o, 3)),
										e.push({ type_: "1000 separator" });
								e.push(t.text_.substr(o));
							} else e.push(t.text_);
							for (var a in t) delete t[a];
							return e;
						},
					},
				},
			};
			var c = {
				go: function (t, e) {
					if (!t) return "";
					for (var n = "", o = !1, a = 0; a < t.length; a++) {
						var r = t[a];
						"string" == typeof r
							? (n += r)
							: ((n += c._go2(r)), "1st-level escape" === r.type_ && (o = !0));
					}
					return e || o || !n || (n = "{" + n + "}"), n;
				},
				_goInner: function (t) {
					return t ? c.go(t, !0) : t;
				},
				_go2: function (t) {
					var e;
					switch (t.type_) {
						case "chemfive":
							e = "";
							var n = {
								a: c._goInner(t.a),
								b: c._goInner(t.b),
								p: c._goInner(t.p),
								o: c._goInner(t.o),
								q: c._goInner(t.q),
								d: c._goInner(t.d),
							};
							n.a &&
								(n.a.match(/^[+\-]/) && (n.a = "{" + n.a + "}"),
								(e += n.a + "\\,")),
								(n.b || n.p) &&
									((e += "{\\vphantom{X}}"),
									(e +=
										"^{\\hphantom{" +
										(n.b || "") +
										"}}_{\\hphantom{" +
										(n.p || "") +
										"}}"),
									(e += "{\\vphantom{X}}"),
									(e +=
										"^{\\smash[t]{\\vphantom{2}}\\mathllap{" +
										(n.b || "") +
										"}}"),
									(e +=
										"_{\\vphantom{2}\\mathllap{\\smash[t]{" +
										(n.p || "") +
										"}}}")),
								n.o &&
									(n.o.match(/^[+\-]/) && (n.o = "{" + n.o + "}"), (e += n.o)),
								"kv" === t.dType
									? ((n.d || n.q) && (e += "{\\vphantom{X}}"),
										n.d && (e += "^{" + n.d + "}"),
										n.q && (e += "_{\\smash[t]{" + n.q + "}}"))
									: "oxidation" === t.dType
										? (n.d &&
												((e += "{\\vphantom{X}}"), (e += "^{" + n.d + "}")),
											n.q &&
												((e += "{\\vphantom{X}}"),
												(e += "_{\\smash[t]{" + n.q + "}}")))
										: (n.q &&
												((e += "{\\vphantom{X}}"),
												(e += "_{\\smash[t]{" + n.q + "}}")),
											n.d &&
												((e += "{\\vphantom{X}}"), (e += "^{" + n.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 " + c._goInner(t.p1);
							break;
						case "state of aggregation subscript":
							e = "\\mskip1mu " + c._goInner(t.p1);
							break;
						case "bond":
							if (!(e = c._getBond(t.kind_)))
								throw [
									"MhchemErrorBond",
									"mhchem Error. Unknown bond type (" + t.kind_ + ")",
								];
							break;
						case "frac":
							var o = "\\frac{" + t.p1 + "}{" + t.p2 + "}";
							e =
								"\\mathchoice{\\textstyle" +
								o +
								"}{" +
								o +
								"}{" +
								o +
								"}{" +
								o +
								"}";
							break;
						case "pu-frac":
							var a =
								"\\frac{" + c._goInner(t.p1) + "}{" + c._goInner(t.p2) + "}";
							e =
								"\\mathchoice{\\textstyle" +
								a +
								"}{" +
								a +
								"}{" +
								a +
								"}{" +
								a +
								"}";
							break;
						case "tex-math":
							e = t.p1 + " ";
							break;
						case "frac-ce":
							e = "\\frac{" + c._goInner(t.p1) + "}{" + c._goInner(t.p2) + "}";
							break;
						case "overset":
							e =
								"\\overset{" + c._goInner(t.p1) + "}{" + c._goInner(t.p2) + "}";
							break;
						case "underset":
							e =
								"\\underset{" +
								c._goInner(t.p1) +
								"}{" +
								c._goInner(t.p2) +
								"}";
							break;
						case "underbrace":
							e =
								"\\underbrace{" +
								c._goInner(t.p1) +
								"}_{" +
								c._goInner(t.p2) +
								"}";
							break;
						case "color":
							e = "{\\color{" + t.color1 + "}{" + c._goInner(t.color2) + "}}";
							break;
						case "color0":
							e = "\\color{" + t.color + "}";
							break;
						case "arrow":
							var r = { rd: c._goInner(t.rd), rq: c._goInner(t.rq) },
								i = "\\x" + c._getArrow(t.r);
							r.rq && (i += "[{" + r.rq + "}]"),
								(e = i += r.rd ? "{" + r.rd + "}" : "{}");
							break;
						case "operator":
							e = c._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 "rightleftarrows";
						case "<=>":
						case "\u21cc":
							return "rightleftharpoons";
						case "<=>>":
							return "rightequilibrium";
						case "<<=>":
							return "leftequilibrium";
						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 "{\\mathrlap{\\raisebox{-.1em}{$-$}}\\raisebox{.1em}{$\\tripledash$}}";
						case "~=":
						case "~--":
							return "{\\mathrlap{\\raisebox{-.2em}{$-$}}\\mathrlap{\\raisebox{.2em}{$\\tripledash$}}-}";
						case "-~-":
							return "{\\mathrlap{\\raisebox{-.2em}{$-$}}\\mathrlap{\\raisebox{.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."];
					}
				},
			};
		},
	]).default;
});