From 44a0f69a78b28bef528af7e89776f28a371869b1 Mon Sep 17 00:00:00 2001
From: NGPixel <github@ngpixel.com>
Date: Sun, 29 Mar 2020 17:06:32 -0400
Subject: [PATCH] feat: katex chemical equations support

---
 client/components/editor/editor-markdown.vue  |    1 +
 .../rendering/markdown-katex/mhchem.js        | 1677 +++++++++++++++++
 .../rendering/markdown-katex/renderer.js      |   14 +
 3 files changed, 1692 insertions(+)
 create mode 100644 server/modules/rendering/markdown-katex/mhchem.js

diff --git a/client/components/editor/editor-markdown.vue b/client/components/editor/editor-markdown.vue
index 4ff996d1..6fa32288 100644
--- a/client/components/editor/editor-markdown.vue
+++ b/client/components/editor/editor-markdown.vue
@@ -216,6 +216,7 @@ import mdMark from 'markdown-it-mark'
 import mdFootnote from 'markdown-it-footnote'
 import mdImsize from 'markdown-it-imsize'
 import katex from 'katex'
+import 'katex/dist/contrib/mhchem'
 import twemoji from 'twemoji'
 
 // Prism (Syntax Highlighting)
diff --git a/server/modules/rendering/markdown-katex/mhchem.js b/server/modules/rendering/markdown-katex/mhchem.js
new file mode 100644
index 00000000..4a9860f7
--- /dev/null
+++ b/server/modules/rendering/markdown-katex/mhchem.js
@@ -0,0 +1,1677 @@
+/* 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
+
+
+  //
+  //  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.
+  //
+
+  module.exports = function (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 (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 (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 (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 (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 (input) { return mhchemParser.patterns.findObserveGroups(input, "^", /^\\[a-zA-Z]+\{/, "}", "", "", "{", "}", "", true); },
+        '^\\x{}': function (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 (input) { return mhchemParser.patterns.findObserveGroups(input, "_", /^\\[a-zA-Z]+\{/, "}", "", "", "{", "}", "", true); },
+        '_\\x{}': function (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 (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 (input) { return mhchemParser.patterns.findObserveGroups(input, "", /^\\[a-zA-Z]+\{/, "}", "", "", "{", "}", "", true); },
+        '\\x{}': function (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 (input) { return mhchemParser.patterns.findObserveGroups(input, "\\frac{", "", "", "}", "{", "", "", "}"); },
+        '\\overset{(...)}': function (input) { return mhchemParser.patterns.findObserveGroups(input, "\\overset{", "", "", "}", "{", "", "", "}"); },
+        '\\underset{(...)}': function (input) { return mhchemParser.patterns.findObserveGroups(input, "\\underset{", "", "", "}", "{", "", "", "}"); },
+        '\\underbrace{(...)}': function (input) { return mhchemParser.patterns.findObserveGroups(input, "\\underbrace{", "", "", "}_", "{", "", "", "}"); },
+        '\\color{(...)}0': function (input) { return mhchemParser.patterns.findObserveGroups(input, "\\color{", "", "", "}"); },
+        '\\color{(...)}{(...)}1': function (input) { return mhchemParser.patterns.findObserveGroups(input, "\\color{", "", "", "}", "{", "", "", "}"); },
+        '\\color(...){(...)}2': function (input) { return mhchemParser.patterns.findObserveGroups(input, "\\color", "\\", "", /^(?=\{)/, "{", "", "", "}"); },
+        '\\ce{(...)}': function (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 (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 (input) { return this['amount'](input); },
+        '(KV letters),': /^(?:[A-Z][a-z]{0,2}|i)(?=,)/,
+        'formula$': function (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 (input, begExcl, begIncl, endIncl, endExcl, beg2Excl, beg2Incl, end2Incl, end2Excl, combine) {
+        /** @type {{(input: string, pattern: string | RegExp): string | string[] | null;}} */
+        var _match = function (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 (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 (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 (buffer, m) { buffer.a = (buffer.a || "") + m; },
+      'b=': function (buffer, m) { buffer.b = (buffer.b || "") + m; },
+      'p=': function (buffer, m) { buffer.p = (buffer.p || "") + m; },
+      'o=': function (buffer, m) { buffer.o = (buffer.o || "") + m; },
+      'q=': function (buffer, m) { buffer.q = (buffer.q || "") + m; },
+      'd=': function (buffer, m) { buffer.d = (buffer.d || "") + m; },
+      'rm=': function (buffer, m) { buffer.rm = (buffer.rm || "") + m; },
+      'text=': function (buffer, m) { buffer.text_ = (buffer.text_ || "") + m; },
+      'insert': function (buffer, m, a) { return { type_: a }; },
+      'insert+p1': function (buffer, m, a) { return { type_: a, p1: m }; },
+      'insert+p1+p2': function (buffer, m, a) { return { type_: a, p1: m[0], p2: m[1] }; },
+      'copy': function (buffer, m) { return m; },
+      'rm': function (buffer, m) { return { type_: 'rm', p1: m || ""}; },
+      'text': function (buffer, m) { return mhchemParser.go(m, 'text'); },
+      '{text}': function (buffer, m) {
+        var ret = [ "{" ];
+        mhchemParser.concatArray(ret, mhchemParser.go(m, 'text'));
+        ret.push("}");
+        return ret;
+      },
+      'tex-math': function (buffer, m) { return mhchemParser.go(m, 'tex-math'); },
+      'tex-math tight': function (buffer, m) { return mhchemParser.go(m, 'tex-math tight'); },
+      'bond': function (buffer, m, k) { return { type_: 'bond', kind_: k || m }; },
+      'color0-output': function (buffer, m) { return { type_: 'color0', color: m[0] }; },
+      'ce': function (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 (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 (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 (buffer, m) {
+          buffer.d = m;
+          buffer.dType = 'kv';
+        },
+        'charge or bond': function (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 (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 (buffer) {
+          buffer.o = buffer.a;
+          buffer.a = undefined;
+        },
+        'sb=true': function (buffer) { buffer.sb = true; },
+        'sb=false': function (buffer) { buffer.sb = false; },
+        'beginsWithBond=true': function (buffer) { buffer['beginsWithBond'] = true; },
+        'beginsWithBond=false': function (buffer) { buffer['beginsWithBond'] = false; },
+        'parenthesisLevel++': function (buffer) { buffer['parenthesisLevel']++; },
+        'parenthesisLevel--': function (buffer) { buffer['parenthesisLevel']--; },
+        'state of aggregation': function (buffer, m) {
+          return { type_: 'state of aggregation', p1: mhchemParser.go(m, 'o') };
+        },
+        'comma': function (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 (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) {
+              //ret = [];
+            } 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 (buffer, m) {
+          var ret = [ "{" ];
+          mhchemParser.concatArray(ret, mhchemParser.go(m, 'oxidation'));
+          ret.push("}");
+          return ret;
+        },
+        'frac-output': function (buffer, m) {
+          return { type_: 'frac-ce', p1: mhchemParser.go(m[0]), p2: mhchemParser.go(m[1]) };
+        },
+        'overset-output': function (buffer, m) {
+          return { type_: 'overset', p1: mhchemParser.go(m[0]), p2: mhchemParser.go(m[1]) };
+        },
+        'underset-output': function (buffer, m) {
+          return { type_: 'underset', p1: mhchemParser.go(m[0]), p2: mhchemParser.go(m[1]) };
+        },
+        'underbrace-output': function (buffer, m) {
+          return { type_: 'underbrace', p1: mhchemParser.go(m[0]), p2: mhchemParser.go(m[1]) };
+        },
+        'color-output': function (buffer, m) {
+          return { type_: 'color', color1: m[0], color2: mhchemParser.go(m[1]) };
+        },
+        'r=': function (buffer, m) { buffer.r = m; },
+        'rdt=': function (buffer, m) { buffer.rdt = m; },
+        'rd=': function (buffer, m) { buffer.rd = m; },
+        'rqt=': function (buffer, m) { buffer.rqt = m; },
+        'rq=': function (buffer, m) { buffer.rq = m; },
+        'operator': function (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 (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 (buffer, m) {
+          return { type_: 'state of aggregation subscript', p1: mhchemParser.go(m, 'o') };
+        },
+        'color-output': function (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 (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 (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 (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 (buffer, m) { buffer.o = (buffer.o || "") + "{"+m+"}"; },
+        'output': function (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 () { 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 (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 (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 (buffer, m, p1) { return { type_: 'operator', kind_: (p1 || m) }; },
+        'space': function () { return { type_: 'pu-space-1' }; },
+        'output': function (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 () { return { type_: 'tight cdot' }; },
+        '^(-1)': function (buffer, m) { buffer.rm += "^{"+m+"}"; },
+        'space': function () { return { type_: 'pu-space-2' }; },
+        'output': function (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 () { return { type_: 'commaDecimal' }; },
+        'output-0': function (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 (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 (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 (input) {
+      if (!input) { return input; }
+      return texify.go(input, true);
+    },
+    _go2: function (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:
+          assertNever(buf);
+          throw ["MhchemBugT", "mhchem bug T. Please report."];  // Missing texify rule or unknown MhchemParser output
+      }
+      assertString(res);
+      return res;
+    },
+    _getArrow: function (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:
+          assertNever(a);
+          throw ["MhchemBugT", "mhchem bug T. Please report."];
+      }
+    },
+    _getBond: function (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:
+          assertNever(a);
+          throw ["MhchemBugT", "mhchem bug T. Please report."];
+      }
+    },
+    _getOperator: function (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:
+          assertNever(a);
+          throw ["MhchemBugT", "mhchem bug T. Please report."];
+      }
+    }
+  };
+
+  //
+  // Helpers for code anaylsis
+  // Will show type error at calling position
+  //
+  /** @param {number} a */
+  function assertNever(a) {}
+  /** @param {string} a */
+  function assertString(a) {}
diff --git a/server/modules/rendering/markdown-katex/renderer.js b/server/modules/rendering/markdown-katex/renderer.js
index dfa6c4de..2321ad12 100644
--- a/server/modules/rendering/markdown-katex/renderer.js
+++ b/server/modules/rendering/markdown-katex/renderer.js
@@ -1,4 +1,5 @@
 const katex = require('katex')
+const chemParse = require('./mhchem')
 
 /* global WIKI */
 
@@ -8,6 +9,19 @@ const katex = require('katex')
 //
 // Includes code from https://github.com/liradb2000/markdown-it-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$}}')
+
 module.exports = {
   init (mdinst, conf) {
     if (conf.useInline) {