katex 0.16.32 → 0.16.34

package/dist/contrib/mhchem.js

@@ -80,9 +80,7 @@ var __webpack_exports__ = {};
 /* harmony import */ var katex__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(757);
 /* harmony import */ var katex__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(katex__WEBPACK_IMPORTED_MODULE_0__);
 /* eslint-disable */
-
 /* -*- Mode: JavaScript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
-
 /* vim: set ts=2 et sw=2 tw=80: */
 
 /*************************************************************
@@ -125,26 +123,30 @@ var __webpack_exports__ = {};
  *  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__WEBPACK_IMPORTED_MODULE_0___default().__defineMacro("\\ce", function (context) {
   return chemParse(context.consumeArgs(1)[0], "ce");
 });
-
 katex__WEBPACK_IMPORTED_MODULE_0___default().__defineMacro("\\pu", function (context) {
   return chemParse(context.consumeArgs(1)[0], "pu");
-}); //  Needed for \bond for the ~ forms
+});
+
+//  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__WEBPACK_IMPORTED_MODULE_0___default().__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.
 //
@@ -153,27 +155,23 @@ var chemParse = function (tokens, stateMachine) {
   // Recreate the argument string from KaTeX's array of tokens.
   var str = "";
   var expectedLoc = tokens.length && 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
@@ -185,12 +183,12 @@ var mhchemParser = {
     if (!input) {
       return [];
     }
-
     if (stateMachine === undefined) {
       stateMachine = 'ce';
     }
+    var state = '0';
 
-    var state = '0'; //
+    //
     // String buffers for parsing:
     //
     // buffer.a == amount
@@ -223,79 +221,68 @@ var mhchemParser = {
     // 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, "..."); //
+    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; //
+            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;
             }
@@ -303,11 +290,10 @@ var mhchemParser = {
             return output;
           }
         }
-      } //
+      }
+      //
       // Prevent infinite loop
       //
-
-
       if (watchdog <= 0) {
         throw ["MhchemBugU", "mhchem bug U. Please report."]; // Unexpected character
       }
@@ -351,46 +337,37 @@ var mhchemParser = {
       '-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}\))\}/,
@@ -512,23 +489,19 @@ var mhchemParser = {
       '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
-
+        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],
@@ -536,7 +509,6 @@ var mhchemParser = {
             };
           }
         }
-
         return null;
       },
       'amount2': function (input) {
@@ -547,17 +519,13 @@ var mhchemParser = {
         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])/,
@@ -572,29 +540,21 @@ var mhchemParser = {
           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,
@@ -609,38 +569,27 @@ var mhchemParser = {
               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,
@@ -648,13 +597,10 @@ var mhchemParser = {
         };
       } 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,
@@ -669,7 +615,6 @@ var mhchemParser = {
     //
     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") {
@@ -677,10 +622,8 @@ var mhchemParser = {
       } else {
         // RegExp
         var match = input.match(pattern);
-
         if (match) {
           var mm;
-
           if (match[2]) {
             mm = [match[1], match[2]];
           } else if (match[1]) {
@@ -688,13 +631,11 @@ var mhchemParser = {
           } else {
             mm = match[0];
           }
-
           return {
             match_: mm,
             remainder: input.substr(match[0].length)
           };
         }
-
         return null;
       }
     }
@@ -787,12 +728,10 @@ var mhchemParser = {
     '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({
@@ -800,7 +739,6 @@ var mhchemParser = {
         p1: n[1],
         p2: n[2]
       });
-
       if (n[3]) {
         n[3] = n[3].replace(/\$/g, "");
         ret.push({
@@ -808,7 +746,6 @@ var mhchemParser = {
           p1: n[3]
         });
       }
-
       return ret;
     },
     '9,9': function (buffer, m) {
@@ -823,46 +760,37 @@ var mhchemParser = {
   createTransitions: function (o) {
     var pattern, state;
     /** @type {string[]} */
-
     var stateArray;
-    var i; //
+    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] = {
@@ -872,13 +800,11 @@ var mhchemParser = {
             }
           } 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
@@ -898,14 +824,14 @@ var mhchemParser = {
         }
       }
     }
-
     return transitions;
   },
   stateMachines: {}
-}; //
+};
+
+//
 // Definition of state machines
 //
-
 mhchemParser.stateMachines = {
   //
   // \ce state machines
@@ -1553,7 +1479,6 @@ mhchemParser.stateMachines = {
     actions: {
       'o after d': function (buffer, m) {
         var ret;
-
         if ((buffer.d || "").match(/^[0-9]+$/)) {
           var tmp = buffer.d;
           buffer.d = undefined;
@@ -1562,7 +1487,6 @@ mhchemParser.stateMachines = {
         } else {
           ret = this['output'](buffer);
         }
-
         mhchemParser.actions['o='](buffer, m);
         return ret;
       },
@@ -1587,15 +1511,11 @@ mhchemParser.stateMachines = {
         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({
@@ -1603,7 +1523,6 @@ mhchemParser.stateMachines = {
           });
         } 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));
@@ -1612,7 +1531,6 @@ mhchemParser.stateMachines = {
             mhchemParser.concatArray(ret, mhchemParser.actions['bond'](buffer, m, "-"));
           }
         }
-
         return ret;
       },
       'a to o': function (buffer) {
@@ -1646,7 +1564,6 @@ mhchemParser.stateMachines = {
       'comma': function (buffer, m) {
         var a = m.replace(/\s*$/, '');
         var withSpace = a !== m;
-
         if (withSpace && buffer['parenthesisLevel'] === 0) {
           return {
             type_: 'comma enumeration L',
@@ -1664,21 +1581,18 @@ mhchemParser.stateMachines = {
         //   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 = [];
+          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;
@@ -1694,7 +1608,6 @@ mhchemParser.stateMachines = {
                 buffer.dType = undefined;
               }
             }
-
             ret.push({
               type_: 'chemfive',
               a: mhchemParser.go(buffer.a, 'a'),
@@ -1708,10 +1621,8 @@ mhchemParser.stateMachines = {
           }
         } else {
           // r
-
           /** @type {ParserOutput[]} */
           var rd;
-
           if (buffer.rdt === 'M') {
             rd = mhchemParser.go(buffer.rd, 'tex-math');
           } else if (buffer.rdt === 'T') {
@@ -1723,10 +1634,7 @@ mhchemParser.stateMachines = {
             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') {
@@ -1737,7 +1645,6 @@ mhchemParser.stateMachines = {
           } else {
             rq = mhchemParser.go(buffer.rq);
           }
-
           ret = {
             type_: 'arrow',
             r: buffer.r,
@@ -1745,13 +1652,11 @@ mhchemParser.stateMachines = {
             rq: rq
           };
         }
-
         for (var p in buffer) {
           if (p !== 'parenthesisLevel' && p !== 'beginsWithBond') {
             delete buffer[p];
           }
         }
-
         return ret;
       },
       'oxidation-output': function (buffer, m) {
@@ -1949,11 +1854,9 @@ mhchemParser.stateMachines = {
             type_: 'text',
             p1: buffer.text_
           };
-
           for (var p in buffer) {
             delete buffer[p];
           }
-
           return ret;
         }
       }
@@ -2242,11 +2145,9 @@ mhchemParser.stateMachines = {
             type_: 'tex-math',
             p1: buffer.o
           };
-
           for (var p in buffer) {
             delete buffer[p];
           }
-
           return ret;
         }
       }
@@ -2291,11 +2192,9 @@ mhchemParser.stateMachines = {
             type_: 'tex-math',
             p1: buffer.o
           };
-
           for (var p in buffer) {
             delete buffer[p];
           }
-
           return ret;
         }
       }
@@ -2408,16 +2307,13 @@ mhchemParser.stateMachines = {
       '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'));
@@ -2425,12 +2321,9 @@ mhchemParser.stateMachines = {
               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'
@@ -2442,23 +2335,19 @@ mhchemParser.stateMachines = {
             }
           }
         }
-
         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;
@@ -2478,22 +2367,17 @@ mhchemParser.stateMachines = {
         /** @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");
@@ -2502,7 +2386,6 @@ mhchemParser.stateMachines = {
             d: mhchemParser.go(buffer.d, 'pu'),
             q: mhchemParser.go(buffer.q, 'pu')
           };
-
           if (buffer.o === '//') {
             ret = {
               type_: 'pu-frac',
@@ -2511,7 +2394,6 @@ mhchemParser.stateMachines = {
             };
           } else {
             ret = b5.d;
-
             if (b5.d.length > 1 || b5.q.length > 1) {
               ret.push({
                 type_: ' / '
@@ -2521,18 +2403,15 @@ mhchemParser.stateMachines = {
                 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;
       }
     }
@@ -2600,10 +2479,8 @@ mhchemParser.stateMachines = {
       '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 {
@@ -2613,11 +2490,9 @@ mhchemParser.stateMachines = {
             };
           }
         }
-
         for (var p in buffer) {
           delete buffer[p];
         }
-
         return ret;
       }
     }
@@ -2660,109 +2535,90 @@ mhchemParser.stateMachines = {
         /** @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
+  }
+  //#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 = "";
@@ -2773,52 +2629,45 @@ var texify = {
           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 + "}}";
           }
@@ -2827,7 +2676,6 @@ var texify = {
             res += "{\\vphantom{X}}";
             res += "^{" + b5.d + "}";
           }
-
           if (b5.q) {
             res += "{\\vphantom{X}}";
             res += "_{\\smash[t]{" + b5.q + "}}";
@@ -2837,19 +2685,15 @@ var texify = {
             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{-}");
@@ -2857,196 +2701,147 @@ var texify = {
         } 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;
   },
@@ -3054,34 +2849,24 @@ var texify = {
     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."];
@@ -3091,55 +2876,38 @@ var texify = {
     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."];
@@ -3149,62 +2917,46 @@ var texify = {
     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 analysis
 // Will show type error at calling position
 //
-
 /** @param {number} a */
-
 function assertNever(a) {}
 /** @param {string} a */
-
-
 function assertString(a) {}
 __webpack_exports__ = __webpack_exports__["default"];
 /******/ 	return __webpack_exports__;