solana-docs 0.0.0 → 1.0.0

package/static/katex/contrib/mhchem.mjs

@@ -1,3109 +0,0 @@
-import katex from '../katex.mjs';
-
-/* eslint-disable */
-
-/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
-
-/* vim: set ts=2 et sw=2 tw=80: */
-
-/*************************************************************
- *
- *  KaTeX mhchem.js
- *
- *  This file implements a KaTeX version of mhchem version 3.3.0.
- *  It is adapted from MathJax/extensions/TeX/mhchem.js
- *  It differs from the MathJax version as follows:
- *    1. The interface is changed so that it can be called from KaTeX, not MathJax.
- *    2. \rlap and \llap are replaced with \mathrlap and \mathllap.
- *    3. Four lines of code are edited in order to use \raisebox instead of \raise.
- *    4. The reaction arrow code is simplified. All reaction arrows are rendered
- *       using KaTeX extensible arrows instead of building non-extensible arrows.
- *    5. \tripledash vertical alignment is slightly adjusted.
- *
- *    This code, as other KaTeX code, is released under the MIT license.
- *
- * /*************************************************************
- *
- *  MathJax/extensions/TeX/mhchem.js
- *
- *  Implements the \ce command for handling chemical formulas
- *  from the mhchem LaTeX package.
- *
- *  ---------------------------------------------------------------------
- *
- *  Copyright (c) 2011-2015 The MathJax Consortium
- *  Copyright (c) 2015-2018 Martin Hensel
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- */
-//
-// Coding Style
-//   - use '' for identifiers that can by minified/uglified
-//   - use "" for strings that need to stay untouched
-// version: "3.3.0" for MathJax and KaTeX
-// Add \ce, \pu, and \tripledash to the KaTeX macros.
-katex.__defineMacro("\\ce", function (context) {
-  return chemParse(context.consumeArgs(1)[0], "ce");
-});
-
-katex.__defineMacro("\\pu", function (context) {
-  return chemParse(context.consumeArgs(1)[0], "pu");
-}); //  Needed for \bond for the ~ forms
-//  Raise by 2.56mu, not 2mu. We're raising a hyphen-minus, U+002D, not
-//  a mathematical minus, U+2212. So we need that extra 0.56.
-
-
-katex.__defineMacro("\\tripledash", "{\\vphantom{-}\\raisebox{2.56mu}{$\\mkern2mu" + "\\tiny\\text{-}\\mkern1mu\\text{-}\\mkern1mu\\text{-}\\mkern2mu$}}");
-//  This is the main function for handing the \ce and \pu commands.
-//  It takes the argument to \ce or \pu and returns the corresponding TeX string.
-//
-
-var chemParse = function chemParse(tokens, stateMachine) {
-  // Recreate the argument string from KaTeX's array of tokens.
-  var str = "";
-  var expectedLoc = tokens[tokens.length - 1].loc.start;
-
-  for (var i = tokens.length - 1; i >= 0; i--) {
-    if (tokens[i].loc.start > expectedLoc) {
-      // context.consumeArgs has eaten a space.
-      str += " ";
-      expectedLoc = tokens[i].loc.start;
-    }
-
-    str += tokens[i].text;
-    expectedLoc += tokens[i].text.length;
-  }
-
-  var tex = texify.go(mhchemParser.go(str, stateMachine));
-  return tex;
-}; //
-// Core parser for mhchem syntax  (recursive)
-//
-
-/** @type {MhchemParser} */
-
-
-var mhchemParser = {
-  //
-  // Parses mchem \ce syntax
-  //
-  // Call like
-  //   go("H2O");
-  //
-  go: function go(input, stateMachine) {
-    if (!input) {
-      return [];
-    }
-
-    if (stateMachine === undefined) {
-      stateMachine = 'ce';
-    }
-
-    var state = '0'; //
-    // String buffers for parsing:
-    //
-    // buffer.a == amount
-    // buffer.o == element
-    // buffer.b == left-side superscript
-    // buffer.p == left-side subscript
-    // buffer.q == right-side subscript
-    // buffer.d == right-side superscript
-    //
-    // buffer.r == arrow
-    // buffer.rdt == arrow, script above, type
-    // buffer.rd == arrow, script above, content
-    // buffer.rqt == arrow, script below, type
-    // buffer.rq == arrow, script below, content
-    //
-    // buffer.text_
-    // buffer.rm
-    // etc.
-    //
-    // buffer.parenthesisLevel == int, starting at 0
-    // buffer.sb == bool, space before
-    // buffer.beginsWithBond == bool
-    //
-    // These letters are also used as state names.
-    //
-    // Other states:
-    // 0 == begin of main part (arrow/operator unlikely)
-    // 1 == next entity
-    // 2 == next entity (arrow/operator unlikely)
-    // 3 == next atom
-    // c == macro
-    //
-
-    /** @type {Buffer} */
-
-    var buffer = {};
-    buffer['parenthesisLevel'] = 0;
-    input = input.replace(/\n/g, " ");
-    input = input.replace(/[\u2212\u2013\u2014\u2010]/g, "-");
-    input = input.replace(/[\u2026]/g, "..."); //
-    // Looks through mhchemParser.transitions, to execute a matching action
-    // (recursive)
-    //
-
-    var lastInput;
-    var watchdog = 10;
-    /** @type {ParserOutput[]} */
-
-    var output = [];
-
-    while (true) {
-      if (lastInput !== input) {
-        watchdog = 10;
-        lastInput = input;
-      } else {
-        watchdog--;
-      } //
-      // Find actions in transition table
-      //
-
-
-      var machine = mhchemParser.stateMachines[stateMachine];
-      var t = machine.transitions[state] || machine.transitions['*'];
-
-      iterateTransitions: for (var i = 0; i < t.length; i++) {
-        var matches = mhchemParser.patterns.match_(t[i].pattern, input);
-
-        if (matches) {
-          //
-          // Execute actions
-          //
-          var task = t[i].task;
-
-          for (var iA = 0; iA < task.action_.length; iA++) {
-            var o; //
-            // Find and execute action
-            //
-
-            if (machine.actions[task.action_[iA].type_]) {
-              o = machine.actions[task.action_[iA].type_](buffer, matches.match_, task.action_[iA].option);
-            } else if (mhchemParser.actions[task.action_[iA].type_]) {
-              o = mhchemParser.actions[task.action_[iA].type_](buffer, matches.match_, task.action_[iA].option);
-            } else {
-              throw ["MhchemBugA", "mhchem bug A. Please report. (" + task.action_[iA].type_ + ")"]; // Trying to use non-existing action
-            } //
-            // Add output
-            //
-
-
-            mhchemParser.concatArray(output, o);
-          } //
-          // Set next state,
-          // Shorten input,
-          // Continue with next character
-          //   (= apply only one transition per position)
-          //
-
-
-          state = task.nextState || state;
-
-          if (input.length > 0) {
-            if (!task.revisit) {
-              input = matches.remainder;
-            }
-
-            if (!task.toContinue) {
-              break iterateTransitions;
-            }
-          } else {
-            return output;
-          }
-        }
-      } //
-      // Prevent infinite loop
-      //
-
-
-      if (watchdog <= 0) {
-        throw ["MhchemBugU", "mhchem bug U. Please report."]; // Unexpected character
-      }
-    }
-  },
-  concatArray: function concatArray(a, b) {
-    if (b) {
-      if (Array.isArray(b)) {
-        for (var iB = 0; iB < b.length; iB++) {
-          a.push(b[iB]);
-        }
-      } else {
-        a.push(b);
-      }
-    }
-  },
-  patterns: {
-    //
-    // Matching patterns
-    // either regexps or function that return null or {match_:"a", remainder:"bc"}
-    //
-    patterns: {
-      // property names must not look like integers ("2") for correct property traversal order, later on
-      '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 e99(input) {
-        var m = input.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]+\}))?/);
-
-        if (m && m[0]) {
-          return {
-            match_: m.splice(1),
-            remainder: input.substr(m[0].length)
-          };
-        }
-
-        return null;
-      },
-      '(-)(9)^(-9)': function _(input) {
-        var m = input.match(/^(\+\-|\+\/\-|\+|\-|\\pm\s?)?([0-9]+(?:[,.][0-9]+)?|[0-9]*(?:\.[0-9]+)?)\^([+\-]?[0-9]+|\{[+\-]?[0-9]+\})/);
-
-        if (m && m[0]) {
-          return {
-            match_: m.splice(1),
-            remainder: input.substr(m[0].length)
-          };
-        }
-
-        return null;
-      },
-      'state of aggregation $': function stateOfAggregation$(input) {
-        // ... or crystal system
-        var a = mhchemParser.patterns.findObserveGroups(input, "", /^\([a-z]{1,3}(?=[\),])/, ")", ""); // (aq), (aq,$\infty$), (aq, sat)
-
-        if (a && a.remainder.match(/^($|[\s,;\)\]\}])/)) {
-          return a;
-        } //  AND end of 'phrase'
-
-
-        var m = input.match(/^(?:\((?:\\ca\s?)?\$[amothc]\$\))/); // OR crystal system ($o$) (\ca$c$)
-
-        if (m) {
-          return {
-            match_: m[0],
-            remainder: input.substr(m[0].length)
-          };
-        }
-
-        return null;
-      },
-      '_{(state of aggregation)}$': /^_\{(\([a-z]{1,3}\))\}/,
-      '{[(': /^(?:\\\{|\[|\()/,
-      ')]}': /^(?:\)|\]|\\\})/,
-      ', ': /^[,;]\s*/,
-      ',': /^[,;]/,
-      '.': /^[.]/,
-      '. ': /^([.\u22C5\u00B7\u2022])\s*/,
-      '...': /^\.\.\.(?=$|[^.])/,
-      '* ': /^([*])\s*/,
-      '^{(...)}': function _(input) {
-        return mhchemParser.patterns.findObserveGroups(input, "^{", "", "", "}");
-      },
-      '^($...$)': function $$(input) {
-        return mhchemParser.patterns.findObserveGroups(input, "^", "$", "$", "");
-      },
-      '^a': /^\^([0-9]+|[^\\_])/,
-      '^\\x{}{}': function x(input) {
-        return mhchemParser.patterns.findObserveGroups(input, "^", /^\\[a-zA-Z]+\{/, "}", "", "", "{", "}", "", true);
-      },
-      '^\\x{}': function x(input) {
-        return mhchemParser.patterns.findObserveGroups(input, "^", /^\\[a-zA-Z]+\{/, "}", "");
-      },
-      '^\\x': /^\^(\\[a-zA-Z]+)\s*/,
-      '^(-1)': /^\^(-?\d+)/,
-      '\'': /^'/,
-      '_{(...)}': function _(input) {
-        return mhchemParser.patterns.findObserveGroups(input, "_{", "", "", "}");
-      },
-      '_($...$)': function _$$(input) {
-        return mhchemParser.patterns.findObserveGroups(input, "_", "$", "$", "");
-      },
-      '_9': /^_([+\-]?[0-9]+|[^\\])/,
-      '_\\x{}{}': function _X(input) {
-        return mhchemParser.patterns.findObserveGroups(input, "_", /^\\[a-zA-Z]+\{/, "}", "", "", "{", "}", "", true);
-      },
-      '_\\x{}': function _X(input) {
-        return mhchemParser.patterns.findObserveGroups(input, "_", /^\\[a-zA-Z]+\{/, "}", "");
-      },
-      '_\\x': /^_(\\[a-zA-Z]+)\s*/,
-      '^_': /^(?:\^(?=_)|\_(?=\^)|[\^_]$)/,
-      '{}': /^\{\}/,
-      '{...}': function _(input) {
-        return mhchemParser.patterns.findObserveGroups(input, "", "{", "}", "");
-      },
-      '{(...)}': function _(input) {
-        return mhchemParser.patterns.findObserveGroups(input, "{", "", "", "}");
-      },
-      '$...$': function $$(input) {
-        return mhchemParser.patterns.findObserveGroups(input, "", "$", "$", "");
-      },
-      '${(...)}$': function $$(input) {
-        return mhchemParser.patterns.findObserveGroups(input, "${", "", "", "}$");
-      },
-      '$(...)$': function $$(input) {
-        return mhchemParser.patterns.findObserveGroups(input, "$", "", "", "$");
-      },
-      '=<>': /^[=<>]/,
-      '#': /^[#\u2261]/,
-      '+': /^\+/,
-      '-$': /^-(?=[\s_},;\]/]|$|\([a-z]+\))/,
-      // -space -, -; -] -/ -$ -state-of-aggregation
-      '-9': /^-(?=[0-9])/,
-      '- orbital overlap': /^-(?=(?:[spd]|sp)(?:$|[\s,;\)\]\}]))/,
-      '-': /^-/,
-      'pm-operator': /^(?:\\pm|\$\\pm\$|\+-|\+\/-)/,
-      'operator': /^(?:\+|(?:[\-=<>]|<<|>>|\\approx|\$\\approx\$)(?=\s|$|-?[0-9]))/,
-      'arrowUpDown': /^(?:v|\(v\)|\^|\(\^\))(?=$|[\s,;\)\]\}])/,
-      '\\bond{(...)}': function bond(input) {
-        return mhchemParser.patterns.findObserveGroups(input, "\\bond{", "", "", "}");
-      },
-      '->': /^(?:<->|<-->|->|<-|<=>>|<<=>|<=>|[\u2192\u27F6\u21CC])/,
-      'CMT': /^[CMT](?=\[)/,
-      '[(...)]': function _(input) {
-        return mhchemParser.patterns.findObserveGroups(input, "[", "", "", "]");
-      },
-      '1st-level escape': /^(&|\\\\|\\hline)\s*/,
-      '\\,': /^(?:\\[,\ ;:])/,
-      // \\x - but output no space before
-      '\\x{}{}': function x(input) {
-        return mhchemParser.patterns.findObserveGroups(input, "", /^\\[a-zA-Z]+\{/, "}", "", "", "{", "}", "", true);
-      },
-      '\\x{}': function x(input) {
-        return mhchemParser.patterns.findObserveGroups(input, "", /^\\[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])/,
-      // only those with numbers in front, because the others will be formatted correctly anyway
-      'others': /^[\/~|]/,
-      '\\frac{(...)}': function frac(input) {
-        return mhchemParser.patterns.findObserveGroups(input, "\\frac{", "", "", "}", "{", "", "", "}");
-      },
-      '\\overset{(...)}': function overset(input) {
-        return mhchemParser.patterns.findObserveGroups(input, "\\overset{", "", "", "}", "{", "", "", "}");
-      },
-      '\\underset{(...)}': function underset(input) {
-        return mhchemParser.patterns.findObserveGroups(input, "\\underset{", "", "", "}", "{", "", "", "}");
-      },
-      '\\underbrace{(...)}': function underbrace(input) {
-        return mhchemParser.patterns.findObserveGroups(input, "\\underbrace{", "", "", "}_", "{", "", "", "}");
-      },
-      '\\color{(...)}0': function color0(input) {
-        return mhchemParser.patterns.findObserveGroups(input, "\\color{", "", "", "}");
-      },
-      '\\color{(...)}{(...)}1': function color1(input) {
-        return mhchemParser.patterns.findObserveGroups(input, "\\color{", "", "", "}", "{", "", "", "}");
-      },
-      '\\color(...){(...)}2': function color2(input) {
-        return mhchemParser.patterns.findObserveGroups(input, "\\color", "\\", "", /^(?=\{)/, "{", "", "", "}");
-      },
-      '\\ce{(...)}': function ce(input) {
-        return mhchemParser.patterns.findObserveGroups(input, "\\ce{", "", "", "}");
-      },
-      'oxidation$': /^(?:[+-][IVX]+|\\pm\s*0|\$\\pm\$\s*0)$/,
-      'd-oxidation$': /^(?:[+-]?\s?[IVX]+|\\pm\s*0|\$\\pm\$\s*0)$/,
-      // 0 could be oxidation or charge
-      'roman numeral': /^[IVX]+/,
-      '1/2$': /^[+\-]?(?:[0-9]+|\$[a-z]\$|[a-z])\/[0-9]+(?:\$[a-z]\$|[a-z])?$/,
-      'amount': function amount(input) {
-        var match; // e.g. 2, 0.5, 1/2, -2, n/2, +;  $a$ could be added later in parsing
-
-        match = input.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))/);
-
-        if (match) {
-          return {
-            match_: match[0],
-            remainder: input.substr(match[0].length)
-          };
-        }
-
-        var a = mhchemParser.patterns.findObserveGroups(input, "", "$", "$", "");
-
-        if (a) {
-          // e.g. $2n-1$, $-$
-          match = a.match_.match(/^\$(?:\(?[+\-]?(?:[0-9]*[a-z]?[+\-])?[0-9]*[a-z](?:[+\-][0-9]*[a-z]?)?\)?|\+|-)\$$/);
-
-          if (match) {
-            return {
-              match_: match[0],
-              remainder: input.substr(match[0].length)
-            };
-          }
-        }
-
-        return null;
-      },
-      'amount2': function amount2(input) {
-        return this['amount'](input);
-      },
-      '(KV letters),': /^(?:[A-Z][a-z]{0,2}|i)(?=,)/,
-      'formula$': function formula$(input) {
-        if (input.match(/^\([a-z]+\)$/)) {
-          return null;
-        } // state of aggregation = no formula
-
-
-        var match = input.match(/^(?:[a-z]|(?:[0-9\ \+\-\,\.\(\)]+[a-z])+[0-9\ \+\-\,\.\(\)]*|(?:[a-z][0-9\ \+\-\,\.\(\)]+)+[a-z]?)$/);
-
-        if (match) {
-          return {
-            match_: match[0],
-            remainder: input.substr(match[0].length)
-          };
-        }
-
-        return null;
-      },
-      'uprightEntities': /^(?:pH|pOH|pC|pK|iPr|iBu)(?=$|[^a-zA-Z])/,
-      '/': /^\s*(\/)\s*/,
-      '//': /^\s*(\/\/)\s*/,
-      '*': /^\s*[*.]\s*/
-    },
-    findObserveGroups: function findObserveGroups(input, begExcl, begIncl, endIncl, endExcl, beg2Excl, beg2Incl, end2Incl, end2Excl, combine) {
-      /** @type {{(input: string, pattern: string | RegExp): string | string[] | null;}} */
-      var _match = function _match(input, pattern) {
-        if (typeof pattern === "string") {
-          if (input.indexOf(pattern) !== 0) {
-            return null;
-          }
-
-          return pattern;
-        } else {
-          var match = input.match(pattern);
-
-          if (!match) {
-            return null;
-          }
-
-          return match[0];
-        }
-      };
-      /** @type {{(input: string, i: number, endChars: string | RegExp): {endMatchBegin: number, endMatchEnd: number} | null;}} */
-
-
-      var _findObserveGroups = function _findObserveGroups(input, i, endChars) {
-        var braces = 0;
-
-        while (i < input.length) {
-          var a = input.charAt(i);
-
-          var match = _match(input.substr(i), endChars);
-
-          if (match !== null && braces === 0) {
-            return {
-              endMatchBegin: i,
-              endMatchEnd: i + match.length
-            };
-          } else if (a === "{") {
-            braces++;
-          } else if (a === "}") {
-            if (braces === 0) {
-              throw ["ExtraCloseMissingOpen", "Extra close brace or missing open brace"];
-            } else {
-              braces--;
-            }
-          }
-
-          i++;
-        }
-
-        if (braces > 0) {
-          return null;
-        }
-
-        return null;
-      };
-
-      var match = _match(input, begExcl);
-
-      if (match === null) {
-        return null;
-      }
-
-      input = input.substr(match.length);
-      match = _match(input, begIncl);
-
-      if (match === null) {
-        return null;
-      }
-
-      var e = _findObserveGroups(input, match.length, endIncl || endExcl);
-
-      if (e === null) {
-        return null;
-      }
-
-      var match1 = input.substring(0, endIncl ? e.endMatchEnd : e.endMatchBegin);
-
-      if (!(beg2Excl || beg2Incl)) {
-        return {
-          match_: match1,
-          remainder: input.substr(e.endMatchEnd)
-        };
-      } else {
-        var group2 = this.findObserveGroups(input.substr(e.endMatchEnd), beg2Excl, beg2Incl, end2Incl, end2Excl);
-
-        if (group2 === null) {
-          return null;
-        }
-        /** @type {string[]} */
-
-
-        var matchRet = [match1, group2.match_];
-        return {
-          match_: combine ? matchRet.join("") : matchRet,
-          remainder: group2.remainder
-        };
-      }
-    },
-    //
-    // Matching function
-    // e.g. match("a", input) will look for the regexp called "a" and see if it matches
-    // returns null or {match_:"a", remainder:"bc"}
-    //
-    match_: function match_(m, input) {
-      var pattern = mhchemParser.patterns.patterns[m];
-
-      if (pattern === undefined) {
-        throw ["MhchemBugP", "mhchem bug P. Please report. (" + m + ")"]; // Trying to use non-existing pattern
-      } else if (typeof pattern === "function") {
-        return mhchemParser.patterns.patterns[m](input); // cannot use cached var pattern here, because some pattern functions need this===mhchemParser
-      } else {
-        // RegExp
-        var match = input.match(pattern);
-
-        if (match) {
-          var mm;
-
-          if (match[2]) {
-            mm = [match[1], match[2]];
-          } else if (match[1]) {
-            mm = match[1];
-          } else {
-            mm = match[0];
-          }
-
-          return {
-            match_: mm,
-            remainder: input.substr(match[0].length)
-          };
-        }
-
-        return null;
-      }
-    }
-  },
-  //
-  // Generic state machine actions
-  //
-  actions: {
-    'a=': function a(buffer, m) {
-      buffer.a = (buffer.a || "") + m;
-    },
-    'b=': function b(buffer, m) {
-      buffer.b = (buffer.b || "") + m;
-    },
-    'p=': function p(buffer, m) {
-      buffer.p = (buffer.p || "") + m;
-    },
-    'o=': function o(buffer, m) {
-      buffer.o = (buffer.o || "") + m;
-    },
-    'q=': function q(buffer, m) {
-      buffer.q = (buffer.q || "") + m;
-    },
-    'd=': function d(buffer, m) {
-      buffer.d = (buffer.d || "") + m;
-    },
-    'rm=': function rm(buffer, m) {
-      buffer.rm = (buffer.rm || "") + m;
-    },
-    'text=': function text(buffer, m) {
-      buffer.text_ = (buffer.text_ || "") + m;
-    },
-    'insert': function insert(buffer, m, a) {
-      return {
-        type_: a
-      };
-    },
-    'insert+p1': function insertP1(buffer, m, a) {
-      return {
-        type_: a,
-        p1: m
-      };
-    },
-    'insert+p1+p2': function insertP1P2(buffer, m, a) {
-      return {
-        type_: a,
-        p1: m[0],
-        p2: m[1]
-      };
-    },
-    'copy': function copy(buffer, m) {
-      return m;
-    },
-    'rm': function rm(buffer, m) {
-      return {
-        type_: 'rm',
-        p1: m || ""
-      };
-    },
-    'text': function text(buffer, m) {
-      return mhchemParser.go(m, 'text');
-    },
-    '{text}': function text(buffer, m) {
-      var ret = ["{"];
-      mhchemParser.concatArray(ret, mhchemParser.go(m, 'text'));
-      ret.push("}");
-      return ret;
-    },
-    'tex-math': function texMath(buffer, m) {
-      return mhchemParser.go(m, 'tex-math');
-    },
-    'tex-math tight': function texMathTight(buffer, m) {
-      return mhchemParser.go(m, 'tex-math tight');
-    },
-    'bond': function bond(buffer, m, k) {
-      return {
-        type_: 'bond',
-        kind_: k || m
-      };
-    },
-    'color0-output': function color0Output(buffer, m) {
-      return {
-        type_: 'color0',
-        color: m[0]
-      };
-    },
-    'ce': function ce(buffer, m) {
-      return mhchemParser.go(m);
-    },
-    '1/2': function _(buffer, m) {
-      /** @type {ParserOutput[]} */
-      var ret = [];
-
-      if (m.match(/^[+\-]/)) {
-        ret.push(m.substr(0, 1));
-        m = m.substr(1);
-      }
-
-      var n = m.match(/^([0-9]+|\$[a-z]\$|[a-z])\/([0-9]+)(\$[a-z]\$|[a-z])?$/);
-      n[1] = n[1].replace(/\$/g, "");
-      ret.push({
-        type_: 'frac',
-        p1: n[1],
-        p2: n[2]
-      });
-
-      if (n[3]) {
-        n[3] = n[3].replace(/\$/g, "");
-        ret.push({
-          type_: 'tex-math',
-          p1: n[3]
-        });
-      }
-
-      return ret;
-    },
-    '9,9': function _(buffer, m) {
-      return mhchemParser.go(m, '9,9');
-    }
-  },
-  //
-  // createTransitions
-  // convert  { 'letter': { 'state': { action_: 'output' } } }  to  { 'state' => [ { pattern: 'letter', task: { action_: [{type_: 'output'}] } } ] }
-  // with expansion of 'a|b' to 'a' and 'b' (at 2 places)
-  //
-  createTransitions: function createTransitions(o) {
-    var pattern, state;
-    /** @type {string[]} */
-
-    var stateArray;
-    var i; //
-    // 1. Collect all states
-    //
-
-    /** @type {Transitions} */
-
-    var transitions = {};
-
-    for (pattern in o) {
-      for (state in o[pattern]) {
-        stateArray = state.split("|");
-        o[pattern][state].stateArray = stateArray;
-
-        for (i = 0; i < stateArray.length; i++) {
-          transitions[stateArray[i]] = [];
-        }
-      }
-    } //
-    // 2. Fill states
-    //
-
-
-    for (pattern in o) {
-      for (state in o[pattern]) {
-        stateArray = o[pattern][state].stateArray || [];
-
-        for (i = 0; i < stateArray.length; i++) {
-          //
-          // 2a. Normalize actions into array:  'text=' ==> [{type_:'text='}]
-          // (Note to myself: Resolving the function here would be problematic. It would need .bind (for *this*) and currying (for *option*).)
-          //
-
-          /** @type {any} */
-          var p = o[pattern][state];
-
-          if (p.action_) {
-            p.action_ = [].concat(p.action_);
-
-            for (var k = 0; k < p.action_.length; k++) {
-              if (typeof p.action_[k] === "string") {
-                p.action_[k] = {
-                  type_: p.action_[k]
-                };
-              }
-            }
-          } else {
-            p.action_ = [];
-          } //
-          // 2.b Multi-insert
-          //
-
-
-          var patternArray = pattern.split("|");
-
-          for (var j = 0; j < patternArray.length; j++) {
-            if (stateArray[i] === '*') {
-              // insert into all
-              for (var t in transitions) {
-                transitions[t].push({
-                  pattern: patternArray[j],
-                  task: p
-                });
-              }
-            } else {
-              transitions[stateArray[i]].push({
-                pattern: patternArray[j],
-                task: p
-              });
-            }
-          }
-        }
-      }
-    }
-
-    return transitions;
-  },
-  stateMachines: {}
-}; //
-// Definition of state machines
-//
-
-mhchemParser.stateMachines = {
-  //
-  // \ce state machines
-  //
-  //#region ce
-  'ce': {
-    // main parser
-    transitions: mhchemParser.createTransitions({
-      'empty': {
-        '*': {
-          action_: 'output'
-        }
-      },
-      'else': {
-        '0|1|2': {
-          action_: 'beginsWithBond=false',
-          revisit: true,
-          toContinue: true
-        }
-      },
-      '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: false
-          },
-          nextState: '2'
-        },
-        'q': {
-          action_: {
-            type_: '- after o/d',
-            option: false
-          },
-          nextState: '2'
-        },
-        'd|qd|dq': {
-          action_: {
-            type_: '- after o/d',
-            option: true
-          },
-          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'
-        }
-      },
-      '^_': {
-        // ^ and _ without a sensible argument
-        '*': {}
-      },
-      '^{(...)}|^($...$)': {
-        '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='
-        },
-        // 2$n$
-        '0|1|2|3|as|b|p|bp|o': {
-          action_: 'o=',
-          nextState: 'o'
-        },
-        // not 'amount'
-        '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: true
-        },
-        'as': {
-          action_: ['output', 'sb=true'],
-          nextState: '1',
-          revisit: true
-        },
-        'r|rt|rd|rdt|rdq': {
-          action_: ['output'],
-          nextState: '0',
-          revisit: true
-        },
-        '*': {
-          action_: ['output', 'copy'],
-          nextState: '3'
-        }
-      }
-    }),
-    actions: {
-      'o after d': function oAfterD(buffer, m) {
-        var ret;
-
-        if ((buffer.d || "").match(/^[0-9]+$/)) {
-          var tmp = buffer.d;
-          buffer.d = undefined;
-          ret = this['output'](buffer);
-          buffer.b = tmp;
-        } else {
-          ret = this['output'](buffer);
-        }
-
-        mhchemParser.actions['o='](buffer, m);
-        return ret;
-      },
-      'd= kv': function dKv(buffer, m) {
-        buffer.d = m;
-        buffer.dType = 'kv';
-      },
-      'charge or bond': function chargeOrBond(buffer, m) {
-        if (buffer['beginsWithBond']) {
-          /** @type {ParserOutput[]} */
-          var ret = [];
-          mhchemParser.concatArray(ret, this['output'](buffer));
-          mhchemParser.concatArray(ret, mhchemParser.actions['bond'](buffer, m, "-"));
-          return ret;
-        } else {
-          buffer.d = m;
-        }
-      },
-      '- after o/d': function afterOD(buffer, m, isAfterD) {
-        var c1 = mhchemParser.patterns.match_('orbital', buffer.o || "");
-        var c2 = mhchemParser.patterns.match_('one lowercase greek letter $', buffer.o || "");
-        var c3 = mhchemParser.patterns.match_('one lowercase latin letter $', buffer.o || "");
-        var c4 = mhchemParser.patterns.match_('$one lowercase latin letter$ $', buffer.o || "");
-        var hyphenFollows = m === "-" && (c1 && c1.remainder === "" || c2 || c3 || c4);
-
-        if (hyphenFollows && !buffer.a && !buffer.b && !buffer.p && !buffer.d && !buffer.q && !c1 && c3) {
-          buffer.o = '$' + buffer.o + '$';
-        }
-        /** @type {ParserOutput[]} */
-
-
-        var ret = [];
-
-        if (hyphenFollows) {
-          mhchemParser.concatArray(ret, this['output'](buffer));
-          ret.push({
-            type_: 'hyphen'
-          });
-        } else {
-          c1 = mhchemParser.patterns.match_('digits', buffer.d || "");
-
-          if (isAfterD && c1 && c1.remainder === '') {
-            mhchemParser.concatArray(ret, mhchemParser.actions['d='](buffer, m));
-            mhchemParser.concatArray(ret, this['output'](buffer));
-          } else {
-            mhchemParser.concatArray(ret, this['output'](buffer));
-            mhchemParser.concatArray(ret, mhchemParser.actions['bond'](buffer, m, "-"));
-          }
-        }
-
-        return ret;
-      },
-      'a to o': function aToO(buffer) {
-        buffer.o = buffer.a;
-        buffer.a = undefined;
-      },
-      'sb=true': function sbTrue(buffer) {
-        buffer.sb = true;
-      },
-      'sb=false': function sbFalse(buffer) {
-        buffer.sb = false;
-      },
-      'beginsWithBond=true': function beginsWithBondTrue(buffer) {
-        buffer['beginsWithBond'] = true;
-      },
-      'beginsWithBond=false': function beginsWithBondFalse(buffer) {
-        buffer['beginsWithBond'] = false;
-      },
-      'parenthesisLevel++': function parenthesisLevel(buffer) {
-        buffer['parenthesisLevel']++;
-      },
-      'parenthesisLevel--': function parenthesisLevel(buffer) {
-        buffer['parenthesisLevel']--;
-      },
-      'state of aggregation': function stateOfAggregation(buffer, m) {
-        return {
-          type_: 'state of aggregation',
-          p1: mhchemParser.go(m, 'o')
-        };
-      },
-      'comma': function comma(buffer, m) {
-        var a = m.replace(/\s*$/, '');
-        var withSpace = a !== m;
-
-        if (withSpace && buffer['parenthesisLevel'] === 0) {
-          return {
-            type_: 'comma enumeration L',
-            p1: a
-          };
-        } else {
-          return {
-            type_: 'comma enumeration M',
-            p1: a
-          };
-        }
-      },
-      'output': function output(buffer, m, entityFollows) {
-        // entityFollows:
-        //   undefined = if we have nothing else to output, also ignore the just read space (buffer.sb)
-        //   1 = an entity follows, never omit the space if there was one just read before (can only apply to state 1)
-        //   2 = 1 + the entity can have an amount, so output a\, instead of converting it to o (can only apply to states a|as)
-
-        /** @type {ParserOutput | ParserOutput[]} */
-        var ret;
-
-        if (!buffer.r) {
-          ret = [];
-
-          if (!buffer.a && !buffer.b && !buffer.p && !buffer.o && !buffer.q && !buffer.d && !entityFollows) ; else {
-            if (buffer.sb) {
-              ret.push({
-                type_: 'entitySkip'
-              });
-            }
-
-            if (!buffer.o && !buffer.q && !buffer.d && !buffer.b && !buffer.p && entityFollows !== 2) {
-              buffer.o = buffer.a;
-              buffer.a = undefined;
-            } else if (!buffer.o && !buffer.q && !buffer.d && (buffer.b || buffer.p)) {
-              buffer.o = buffer.a;
-              buffer.d = buffer.b;
-              buffer.q = buffer.p;
-              buffer.a = buffer.b = buffer.p = undefined;
-            } else {
-              if (buffer.o && buffer.dType === 'kv' && mhchemParser.patterns.match_('d-oxidation$', buffer.d || "")) {
-                buffer.dType = 'oxidation';
-              } else if (buffer.o && buffer.dType === 'kv' && !buffer.q) {
-                buffer.dType = undefined;
-              }
-            }
-
-            ret.push({
-              type_: 'chemfive',
-              a: mhchemParser.go(buffer.a, 'a'),
-              b: mhchemParser.go(buffer.b, 'bd'),
-              p: mhchemParser.go(buffer.p, 'pq'),
-              o: mhchemParser.go(buffer.o, 'o'),
-              q: mhchemParser.go(buffer.q, 'pq'),
-              d: mhchemParser.go(buffer.d, buffer.dType === 'oxidation' ? 'oxidation' : 'bd'),
-              dType: buffer.dType
-            });
-          }
-        } else {
-          // r
-
-          /** @type {ParserOutput[]} */
-          var rd;
-
-          if (buffer.rdt === 'M') {
-            rd = mhchemParser.go(buffer.rd, 'tex-math');
-          } else if (buffer.rdt === 'T') {
-            rd = [{
-              type_: 'text',
-              p1: buffer.rd || ""
-            }];
-          } else {
-            rd = mhchemParser.go(buffer.rd);
-          }
-          /** @type {ParserOutput[]} */
-
-
-          var rq;
-
-          if (buffer.rqt === 'M') {
-            rq = mhchemParser.go(buffer.rq, 'tex-math');
-          } else if (buffer.rqt === 'T') {
-            rq = [{
-              type_: 'text',
-              p1: buffer.rq || ""
-            }];
-          } else {
-            rq = mhchemParser.go(buffer.rq);
-          }
-
-          ret = {
-            type_: 'arrow',
-            r: buffer.r,
-            rd: rd,
-            rq: rq
-          };
-        }
-
-        for (var p in buffer) {
-          if (p !== 'parenthesisLevel' && p !== 'beginsWithBond') {
-            delete buffer[p];
-          }
-        }
-
-        return ret;
-      },
-      'oxidation-output': function oxidationOutput(buffer, m) {
-        var ret = ["{"];
-        mhchemParser.concatArray(ret, mhchemParser.go(m, 'oxidation'));
-        ret.push("}");
-        return ret;
-      },
-      'frac-output': function fracOutput(buffer, m) {
-        return {
-          type_: 'frac-ce',
-          p1: mhchemParser.go(m[0]),
-          p2: mhchemParser.go(m[1])
-        };
-      },
-      'overset-output': function oversetOutput(buffer, m) {
-        return {
-          type_: 'overset',
-          p1: mhchemParser.go(m[0]),
-          p2: mhchemParser.go(m[1])
-        };
-      },
-      'underset-output': function undersetOutput(buffer, m) {
-        return {
-          type_: 'underset',
-          p1: mhchemParser.go(m[0]),
-          p2: mhchemParser.go(m[1])
-        };
-      },
-      'underbrace-output': function underbraceOutput(buffer, m) {
-        return {
-          type_: 'underbrace',
-          p1: mhchemParser.go(m[0]),
-          p2: mhchemParser.go(m[1])
-        };
-      },
-      'color-output': function colorOutput(buffer, m) {
-        return {
-          type_: 'color',
-          color1: m[0],
-          color2: mhchemParser.go(m[1])
-        };
-      },
-      'r=': function r(buffer, m) {
-        buffer.r = m;
-      },
-      'rdt=': function rdt(buffer, m) {
-        buffer.rdt = m;
-      },
-      'rd=': function rd(buffer, m) {
-        buffer.rd = m;
-      },
-      'rqt=': function rqt(buffer, m) {
-        buffer.rqt = m;
-      },
-      'rq=': function rq(buffer, m) {
-        buffer.rq = m;
-      },
-      'operator': function operator(buffer, m, p1) {
-        return {
-          type_: 'operator',
-          kind_: p1 || m
-        };
-      }
-    }
-  },
-  'a': {
-    transitions: mhchemParser.createTransitions({
-      'empty': {
-        '*': {}
-      },
-      '1/2$': {
-        '0': {
-          action_: '1/2'
-        }
-      },
-      'else': {
-        '0': {
-          nextState: '1',
-          revisit: true
-        }
-      },
-      '$(...)$': {
-        '*': {
-          action_: 'tex-math tight',
-          nextState: '1'
-        }
-      },
-      ',': {
-        '*': {
-          action_: {
-            type_: 'insert',
-            option: 'commaDecimal'
-          }
-        }
-      },
-      'else2': {
-        '*': {
-          action_: 'copy'
-        }
-      }
-    }),
-    actions: {}
-  },
-  'o': {
-    transitions: mhchemParser.createTransitions({
-      'empty': {
-        '*': {}
-      },
-      '1/2$': {
-        '0': {
-          action_: '1/2'
-        }
-      },
-      'else': {
-        '0': {
-          nextState: '1',
-          revisit: true
-        }
-      },
-      '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: mhchemParser.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 output(buffer) {
-        if (buffer.text_) {
-          /** @type {ParserOutput} */
-          var ret = {
-            type_: 'text',
-            p1: buffer.text_
-          };
-
-          for (var p in buffer) {
-            delete buffer[p];
-          }
-
-          return ret;
-        }
-      }
-    }
-  },
-  'pq': {
-    transitions: mhchemParser.createTransitions({
-      'empty': {
-        '*': {}
-      },
-      'state of aggregation $': {
-        '*': {
-          action_: 'state of aggregation'
-        }
-      },
-      'i$': {
-        '0': {
-          nextState: '!f',
-          revisit: true
-        }
-      },
-      '(KV letters),': {
-        '0': {
-          action_: 'rm',
-          nextState: '0'
-        }
-      },
-      'formula$': {
-        '0': {
-          nextState: 'f',
-          revisit: true
-        }
-      },
-      '1/2$': {
-        '0': {
-          action_: '1/2'
-        }
-      },
-      'else': {
-        '0': {
-          nextState: '!f',
-          revisit: true
-        }
-      },
-      '${(...)}$|$(...)$': {
-        '*': {
-          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 stateOfAggregation(buffer, m) {
-        return {
-          type_: 'state of aggregation subscript',
-          p1: mhchemParser.go(m, 'o')
-        };
-      },
-      'color-output': function colorOutput(buffer, m) {
-        return {
-          type_: 'color',
-          color1: m[0],
-          color2: mhchemParser.go(m[1], 'pq')
-        };
-      }
-    }
-  },
-  'bd': {
-    transitions: mhchemParser.createTransitions({
-      'empty': {
-        '*': {}
-      },
-      'x$': {
-        '0': {
-          nextState: '!f',
-          revisit: true
-        }
-      },
-      'formula$': {
-        '0': {
-          nextState: 'f',
-          revisit: true
-        }
-      },
-      'else': {
-        '0': {
-          nextState: '!f',
-          revisit: true
-        }
-      },
-      '-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 colorOutput(buffer, m) {
-        return {
-          type_: 'color',
-          color1: m[0],
-          color2: mhchemParser.go(m[1], 'bd')
-        };
-      }
-    }
-  },
-  'oxidation': {
-    transitions: mhchemParser.createTransitions({
-      'empty': {
-        '*': {}
-      },
-      'roman numeral': {
-        '*': {
-          action_: 'roman-numeral'
-        }
-      },
-      '${(...)}$|$(...)$': {
-        '*': {
-          action_: 'tex-math'
-        }
-      },
-      'else': {
-        '*': {
-          action_: 'copy'
-        }
-      }
-    }),
-    actions: {
-      'roman-numeral': function romanNumeral(buffer, m) {
-        return {
-          type_: 'roman numeral',
-          p1: m || ""
-        };
-      }
-    }
-  },
-  'tex-math': {
-    transitions: mhchemParser.createTransitions({
-      'empty': {
-        '*': {
-          action_: 'output'
-        }
-      },
-      '\\ce{(...)}': {
-        '*': {
-          action_: ['output', 'ce']
-        }
-      },
-      '{...}|\\,|\\x{}{}|\\x{}|\\x': {
-        '*': {
-          action_: 'o='
-        }
-      },
-      'else': {
-        '*': {
-          action_: 'o='
-        }
-      }
-    }),
-    actions: {
-      'output': function output(buffer) {
-        if (buffer.o) {
-          /** @type {ParserOutput} */
-          var ret = {
-            type_: 'tex-math',
-            p1: buffer.o
-          };
-
-          for (var p in buffer) {
-            delete buffer[p];
-          }
-
-          return ret;
-        }
-      }
-    }
-  },
-  'tex-math tight': {
-    transitions: mhchemParser.createTransitions({
-      'empty': {
-        '*': {
-          action_: 'output'
-        }
-      },
-      '\\ce{(...)}': {
-        '*': {
-          action_: ['output', 'ce']
-        }
-      },
-      '{...}|\\,|\\x{}{}|\\x{}|\\x': {
-        '*': {
-          action_: 'o='
-        }
-      },
-      '-|+': {
-        '*': {
-          action_: 'tight operator'
-        }
-      },
-      'else': {
-        '*': {
-          action_: 'o='
-        }
-      }
-    }),
-    actions: {
-      'tight operator': function tightOperator(buffer, m) {
-        buffer.o = (buffer.o || "") + "{" + m + "}";
-      },
-      'output': function output(buffer) {
-        if (buffer.o) {
-          /** @type {ParserOutput} */
-          var ret = {
-            type_: 'tex-math',
-            p1: buffer.o
-          };
-
-          for (var p in buffer) {
-            delete buffer[p];
-          }
-
-          return ret;
-        }
-      }
-    }
-  },
-  '9,9': {
-    transitions: mhchemParser.createTransitions({
-      'empty': {
-        '*': {}
-      },
-      ',': {
-        '*': {
-          action_: 'comma'
-        }
-      },
-      'else': {
-        '*': {
-          action_: 'copy'
-        }
-      }
-    }),
-    actions: {
-      'comma': function comma() {
-        return {
-          type_: 'commaDecimal'
-        };
-      }
-    }
-  },
-  //#endregion
-  //
-  // \pu state machines
-  //
-  //#region pu
-  'pu': {
-    transitions: mhchemParser.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 enumber(buffer, m) {
-        /** @type {ParserOutput[]} */
-        var ret = [];
-
-        if (m[0] === "+-" || m[0] === "+/-") {
-          ret.push("\\pm ");
-        } else if (m[0]) {
-          ret.push(m[0]);
-        }
-
-        if (m[1]) {
-          mhchemParser.concatArray(ret, mhchemParser.go(m[1], 'pu-9,9'));
-
-          if (m[2]) {
-            if (m[2].match(/[,.]/)) {
-              mhchemParser.concatArray(ret, mhchemParser.go(m[2], 'pu-9,9'));
-            } else {
-              ret.push(m[2]);
-            }
-          }
-
-          m[3] = m[4] || m[3];
-
-          if (m[3]) {
-            m[3] = m[3].trim();
-
-            if (m[3] === "e" || m[3].substr(0, 1) === "*") {
-              ret.push({
-                type_: 'cdot'
-              });
-            } else {
-              ret.push({
-                type_: 'times'
-              });
-            }
-          }
-        }
-
-        if (m[3]) {
-          ret.push("10^{" + m[5] + "}");
-        }
-
-        return ret;
-      },
-      'number^': function number(buffer, m) {
-        /** @type {ParserOutput[]} */
-        var ret = [];
-
-        if (m[0] === "+-" || m[0] === "+/-") {
-          ret.push("\\pm ");
-        } else if (m[0]) {
-          ret.push(m[0]);
-        }
-
-        mhchemParser.concatArray(ret, mhchemParser.go(m[1], 'pu-9,9'));
-        ret.push("^{" + m[2] + "}");
-        return ret;
-      },
-      'operator': function operator(buffer, m, p1) {
-        return {
-          type_: 'operator',
-          kind_: p1 || m
-        };
-      },
-      'space': function space() {
-        return {
-          type_: 'pu-space-1'
-        };
-      },
-      'output': function output(buffer) {
-        /** @type {ParserOutput | ParserOutput[]} */
-        var ret;
-        var md = mhchemParser.patterns.match_('{(...)}', buffer.d || "");
-
-        if (md && md.remainder === '') {
-          buffer.d = md.match_;
-        }
-
-        var mq = mhchemParser.patterns.match_('{(...)}', buffer.q || "");
-
-        if (mq && mq.remainder === '') {
-          buffer.q = mq.match_;
-        }
-
-        if (buffer.d) {
-          buffer.d = buffer.d.replace(/\u00B0C|\^oC|\^{o}C/g, "{}^{\\circ}C");
-          buffer.d = buffer.d.replace(/\u00B0F|\^oF|\^{o}F/g, "{}^{\\circ}F");
-        }
-
-        if (buffer.q) {
-          // fraction
-          buffer.q = buffer.q.replace(/\u00B0C|\^oC|\^{o}C/g, "{}^{\\circ}C");
-          buffer.q = buffer.q.replace(/\u00B0F|\^oF|\^{o}F/g, "{}^{\\circ}F");
-          var b5 = {
-            d: mhchemParser.go(buffer.d, 'pu'),
-            q: mhchemParser.go(buffer.q, 'pu')
-          };
-
-          if (buffer.o === '//') {
-            ret = {
-              type_: 'pu-frac',
-              p1: b5.d,
-              p2: b5.q
-            };
-          } else {
-            ret = b5.d;
-
-            if (b5.d.length > 1 || b5.q.length > 1) {
-              ret.push({
-                type_: ' / '
-              });
-            } else {
-              ret.push({
-                type_: '/'
-              });
-            }
-
-            mhchemParser.concatArray(ret, b5.q);
-          }
-        } else {
-          // no fraction
-          ret = mhchemParser.go(buffer.d, 'pu-2');
-        }
-
-        for (var p in buffer) {
-          delete buffer[p];
-        }
-
-        return ret;
-      }
-    }
-  },
-  'pu-2': {
-    transitions: mhchemParser.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 cdot() {
-        return {
-          type_: 'tight cdot'
-        };
-      },
-      '^(-1)': function _(buffer, m) {
-        buffer.rm += "^{" + m + "}";
-      },
-      'space': function space() {
-        return {
-          type_: 'pu-space-2'
-        };
-      },
-      'output': function output(buffer) {
-        /** @type {ParserOutput | ParserOutput[]} */
-        var ret = [];
-
-        if (buffer.rm) {
-          var mrm = mhchemParser.patterns.match_('{(...)}', buffer.rm || "");
-
-          if (mrm && mrm.remainder === '') {
-            ret = mhchemParser.go(mrm.match_, 'pu');
-          } else {
-            ret = {
-              type_: 'rm',
-              p1: buffer.rm
-            };
-          }
-        }
-
-        for (var p in buffer) {
-          delete buffer[p];
-        }
-
-        return ret;
-      }
-    }
-  },
-  'pu-9,9': {
-    transitions: mhchemParser.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 comma() {
-        return {
-          type_: 'commaDecimal'
-        };
-      },
-      'output-0': function output0(buffer) {
-        /** @type {ParserOutput[]} */
-        var ret = [];
-        buffer.text_ = buffer.text_ || "";
-
-        if (buffer.text_.length > 4) {
-          var a = buffer.text_.length % 3;
-
-          if (a === 0) {
-            a = 3;
-          }
-
-          for (var i = buffer.text_.length - 3; i > 0; i -= 3) {
-            ret.push(buffer.text_.substr(i, 3));
-            ret.push({
-              type_: '1000 separator'
-            });
-          }
-
-          ret.push(buffer.text_.substr(0, a));
-          ret.reverse();
-        } else {
-          ret.push(buffer.text_);
-        }
-
-        for (var p in buffer) {
-          delete buffer[p];
-        }
-
-        return ret;
-      },
-      'output-o': function outputO(buffer) {
-        /** @type {ParserOutput[]} */
-        var ret = [];
-        buffer.text_ = buffer.text_ || "";
-
-        if (buffer.text_.length > 4) {
-          var a = buffer.text_.length - 3;
-
-          for (var i = 0; i < a; i += 3) {
-            ret.push(buffer.text_.substr(i, 3));
-            ret.push({
-              type_: '1000 separator'
-            });
-          }
-
-          ret.push(buffer.text_.substr(i));
-        } else {
-          ret.push(buffer.text_);
-        }
-
-        for (var p in buffer) {
-          delete buffer[p];
-        }
-
-        return ret;
-      }
-    } //#endregion
-
-  }
-}; //
-// texify: Take MhchemParser output and convert it to TeX
-//
-
-/** @type {Texify} */
-
-var texify = {
-  go: function go(input, isInner) {
-    // (recursive, max 4 levels)
-    if (!input) {
-      return "";
-    }
-
-    var res = "";
-    var cee = false;
-
-    for (var i = 0; i < input.length; i++) {
-      var inputi = input[i];
-
-      if (typeof inputi === "string") {
-        res += inputi;
-      } else {
-        res += texify._go2(inputi);
-
-        if (inputi.type_ === '1st-level escape') {
-          cee = true;
-        }
-      }
-    }
-
-    if (!isInner && !cee && res) {
-      res = "{" + res + "}";
-    }
-
-    return res;
-  },
-  _goInner: function _goInner(input) {
-    if (!input) {
-      return input;
-    }
-
-    return texify.go(input, true);
-  },
-  _go2: function _go2(buf) {
-    /** @type {undefined | string} */
-    var res;
-
-    switch (buf.type_) {
-      case 'chemfive':
-        res = "";
-        var b5 = {
-          a: texify._goInner(buf.a),
-          b: texify._goInner(buf.b),
-          p: texify._goInner(buf.p),
-          o: texify._goInner(buf.o),
-          q: texify._goInner(buf.q),
-          d: texify._goInner(buf.d)
-        }; //
-        // a
-        //
-
-        if (b5.a) {
-          if (b5.a.match(/^[+\-]/)) {
-            b5.a = "{" + b5.a + "}";
-          }
-
-          res += b5.a + "\\,";
-        } //
-        // b and p
-        //
-
-
-        if (b5.b || b5.p) {
-          res += "{\\vphantom{X}}";
-          res += "^{\\hphantom{" + (b5.b || "") + "}}_{\\hphantom{" + (b5.p || "") + "}}";
-          res += "{\\vphantom{X}}";
-          res += "^{\\smash[t]{\\vphantom{2}}\\mathllap{" + (b5.b || "") + "}}";
-          res += "_{\\vphantom{2}\\mathllap{\\smash[t]{" + (b5.p || "") + "}}}";
-        } //
-        // o
-        //
-
-
-        if (b5.o) {
-          if (b5.o.match(/^[+\-]/)) {
-            b5.o = "{" + b5.o + "}";
-          }
-
-          res += b5.o;
-        } //
-        // q and d
-        //
-
-
-        if (buf.dType === 'kv') {
-          if (b5.d || b5.q) {
-            res += "{\\vphantom{X}}";
-          }
-
-          if (b5.d) {
-            res += "^{" + b5.d + "}";
-          }
-
-          if (b5.q) {
-            res += "_{\\smash[t]{" + b5.q + "}}";
-          }
-        } else if (buf.dType === 'oxidation') {
-          if (b5.d) {
-            res += "{\\vphantom{X}}";
-            res += "^{" + b5.d + "}";
-          }
-
-          if (b5.q) {
-            res += "{\\vphantom{X}}";
-            res += "_{\\smash[t]{" + b5.q + "}}";
-          }
-        } else {
-          if (b5.q) {
-            res += "{\\vphantom{X}}";
-            res += "_{\\smash[t]{" + b5.q + "}}";
-          }
-
-          if (b5.d) {
-            res += "{\\vphantom{X}}";
-            res += "^{" + b5.d + "}";
-          }
-        }
-
-        break;
-
-      case 'rm':
-        res = "\\mathrm{" + buf.p1 + "}";
-        break;
-
-      case 'text':
-        if (buf.p1.match(/[\^_]/)) {
-          buf.p1 = buf.p1.replace(" ", "~").replace("-", "\\text{-}");
-          res = "\\mathrm{" + buf.p1 + "}";
-        } else {
-          res = "\\text{" + buf.p1 + "}";
-        }
-
-        break;
-
-      case 'roman numeral':
-        res = "\\mathrm{" + buf.p1 + "}";
-        break;
-
-      case 'state of aggregation':
-        res = "\\mskip2mu " + texify._goInner(buf.p1);
-        break;
-
-      case 'state of aggregation subscript':
-        res = "\\mskip1mu " + texify._goInner(buf.p1);
-        break;
-
-      case 'bond':
-        res = texify._getBond(buf.kind_);
-
-        if (!res) {
-          throw ["MhchemErrorBond", "mhchem Error. Unknown bond type (" + buf.kind_ + ")"];
-        }
-
-        break;
-
-      case 'frac':
-        var c = "\\frac{" + buf.p1 + "}{" + buf.p2 + "}";
-        res = "\\mathchoice{\\textstyle" + c + "}{" + c + "}{" + c + "}{" + c + "}";
-        break;
-
-      case 'pu-frac':
-        var d = "\\frac{" + texify._goInner(buf.p1) + "}{" + texify._goInner(buf.p2) + "}";
-        res = "\\mathchoice{\\textstyle" + d + "}{" + d + "}{" + d + "}{" + d + "}";
-        break;
-
-      case 'tex-math':
-        res = buf.p1 + " ";
-        break;
-
-      case 'frac-ce':
-        res = "\\frac{" + texify._goInner(buf.p1) + "}{" + texify._goInner(buf.p2) + "}";
-        break;
-
-      case 'overset':
-        res = "\\overset{" + texify._goInner(buf.p1) + "}{" + texify._goInner(buf.p2) + "}";
-        break;
-
-      case 'underset':
-        res = "\\underset{" + texify._goInner(buf.p1) + "}{" + texify._goInner(buf.p2) + "}";
-        break;
-
-      case 'underbrace':
-        res = "\\underbrace{" + texify._goInner(buf.p1) + "}_{" + texify._goInner(buf.p2) + "}";
-        break;
-
-      case 'color':
-        res = "{\\color{" + buf.color1 + "}{" + texify._goInner(buf.color2) + "}}";
-        break;
-
-      case 'color0':
-        res = "\\color{" + buf.color + "}";
-        break;
-
-      case 'arrow':
-        var b6 = {
-          rd: texify._goInner(buf.rd),
-          rq: texify._goInner(buf.rq)
-        };
-
-        var arrow = "\\x" + texify._getArrow(buf.r);
-
-        if (b6.rq) {
-          arrow += "[{" + b6.rq + "}]";
-        }
-
-        if (b6.rd) {
-          arrow += "{" + b6.rd + "}";
-        } else {
-          arrow += "{}";
-        }
-
-        res = arrow;
-        break;
-
-      case 'operator':
-        res = texify._getOperator(buf.kind_);
-        break;
-
-      case '1st-level escape':
-        res = buf.p1 + " "; // &, \\\\, \\hlin
-
-        break;
-
-      case 'space':
-        res = " ";
-        break;
-
-      case 'entitySkip':
-        res = "~";
-        break;
-
-      case 'pu-space-1':
-        res = "~";
-        break;
-
-      case 'pu-space-2':
-        res = "\\mkern3mu ";
-        break;
-
-      case '1000 separator':
-        res = "\\mkern2mu ";
-        break;
-
-      case 'commaDecimal':
-        res = "{,}";
-        break;
-
-      case 'comma enumeration L':
-        res = "{" + buf.p1 + "}\\mkern6mu ";
-        break;
-
-      case 'comma enumeration M':
-        res = "{" + buf.p1 + "}\\mkern3mu ";
-        break;
-
-      case 'comma enumeration S':
-        res = "{" + buf.p1 + "}\\mkern1mu ";
-        break;
-
-      case 'hyphen':
-        res = "\\text{-}";
-        break;
-
-      case 'addition compound':
-        res = "\\,{\\cdot}\\,";
-        break;
-
-      case 'electron dot':
-        res = "\\mkern1mu \\bullet\\mkern1mu ";
-        break;
-
-      case 'KV x':
-        res = "{\\times}";
-        break;
-
-      case 'prime':
-        res = "\\prime ";
-        break;
-
-      case 'cdot':
-        res = "\\cdot ";
-        break;
-
-      case 'tight cdot':
-        res = "\\mkern1mu{\\cdot}\\mkern1mu ";
-        break;
-
-      case 'times':
-        res = "\\times ";
-        break;
-
-      case 'circa':
-        res = "{\\sim}";
-        break;
-
-      case '^':
-        res = "uparrow";
-        break;
-
-      case 'v':
-        res = "downarrow";
-        break;
-
-      case 'ellipsis':
-        res = "\\ldots ";
-        break;
-
-      case '/':
-        res = "/";
-        break;
-
-      case ' / ':
-        res = "\\,/\\,";
-        break;
-
-      default:
-        throw ["MhchemBugT", "mhchem bug T. Please report."];
-      // Missing texify rule or unknown MhchemParser output
-    }
-    return res;
-  },
-  _getArrow: function _getArrow(a) {
-    switch (a) {
-      case "->":
-        return "rightarrow";
-
-      case "\u2192":
-        return "rightarrow";
-
-      case "\u27F6":
-        return "rightarrow";
-
-      case "<-":
-        return "leftarrow";
-
-      case "<->":
-        return "leftrightarrow";
-
-      case "<-->":
-        return "rightleftarrows";
-
-      case "<=>":
-        return "rightleftharpoons";
-
-      case "\u21CC":
-        return "rightleftharpoons";
-
-      case "<=>>":
-        return "rightequilibrium";
-
-      case "<<=>":
-        return "leftequilibrium";
-
-      default:
-        throw ["MhchemBugT", "mhchem bug T. Please report."];
-    }
-  },
-  _getBond: function _getBond(a) {
-    switch (a) {
-      case "-":
-        return "{-}";
-
-      case "1":
-        return "{-}";
-
-      case "=":
-        return "{=}";
-
-      case "2":
-        return "{=}";
-
-      case "#":
-        return "{\\equiv}";
-
-      case "3":
-        return "{\\equiv}";
-
-      case "~":
-        return "{\\tripledash}";
-
-      case "~-":
-        return "{\\mathrlap{\\raisebox{-.1em}{$-$}}\\raisebox{.1em}{$\\tripledash$}}";
-
-      case "~=":
-        return "{\\mathrlap{\\raisebox{-.2em}{$-$}}\\mathrlap{\\raisebox{.2em}{$\\tripledash$}}-}";
-
-      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 _getOperator(a) {
-    switch (a) {
-      case "+":
-        return " {}+{} ";
-
-      case "-":
-        return " {}-{} ";
-
-      case "=":
-        return " {}={} ";
-
-      case "<":
-        return " {}<{} ";
-
-      case ">":
-        return " {}>{} ";
-
-      case "<<":
-        return " {}\\ll{} ";
-
-      case ">>":
-        return " {}\\gg{} ";
-
-      case "\\pm":
-        return " {}\\pm{} ";
-
-      case "\\approx":
-        return " {}\\approx{} ";
-
-      case "$\\approx$":
-        return " {}\\approx{} ";
-
-      case "v":
-        return " \\downarrow{} ";
-
-      case "(v)":
-        return " \\downarrow{} ";
-
-      case "^":
-        return " \\uparrow{} ";
-
-      case "(^)":
-        return " \\uparrow{} ";
-
-      default:
-        throw ["MhchemBugT", "mhchem bug T. Please report."];
-    }
-  }
-}; //