katex 0.11.1 → 0.12.0

package/dist/katex.mjs

@@ -56,10 +56,14 @@ class SourceLocation {
  * lead to degraded error reporting, though.
  */
 class Token {
+  // don't expand the token
+  // used in \noexpand
   constructor(text, // the text of this token
   loc) {
     this.text = void 0;
     this.loc = void 0;
+    this.noexpand = void 0;
+    this.treatAsRelax = void 0;
     this.text = text;
     this.loc = loc;
   }
@@ -282,6 +286,7 @@ class Settings {
     this.trust = void 0;
     this.maxSize = void 0;
     this.maxExpand = void 0;
+    this.globalGroup = void 0;
     // allow null options
     options = options || {};
     this.displayMode = utils.deflt(options.displayMode, false);
@@ -297,6 +302,7 @@ class Settings {
     this.trust = utils.deflt(options.trust, false);
     this.maxSize = Math.max(0, utils.deflt(options.maxSize, Infinity));
     this.maxExpand = Math.max(0, utils.deflt(options.maxExpand, 1000));
+    this.globalGroup = utils.deflt(options.globalGroup, false);
   }
   /**
    * Report nonstrict (non-LaTeX-compatible) input.
@@ -745,6 +751,9 @@ const sqrtPath = function sqrtPath(size, extraViniculum, viewBoxHeight) {
   return path;
 };
 const path = {
+  // Two paths that cover gaps in built-up parentheses.
+  leftParenInner: `M291 0 H417 V300 H291 z`,
+  rightParenInner: `M457 0 H583 V300 H457 z`,
   // The doubleleftarrow geometry is from glyph U+21D0 in the font KaTeX Main
   doubleleftarrow: `M262 157
 l10-10c34-36 62.7-77 86-123 3.3-8 5-13.3 5-16 0-5.3-6.7-8-20-8-7.3
@@ -1594,6 +1603,7 @@ function assertSpan(group) {
 // This file is GENERATED by buildMetrics.sh. DO NOT MODIFY.
 var metricMap = {
   "AMS-Regular": {
+    "32": [0, 0, 0, 0, 0.25],
     "65": [0, 0.68889, 0, 0, 0.72222],
     "66": [0, 0.68889, 0, 0, 0.66667],
     "67": [0, 0.68889, 0, 0, 0.72222],
@@ -1621,6 +1631,7 @@ var metricMap = {
     "89": [0, 0.68889, 0, 0, 0.72222],
     "90": [0, 0.68889, 0, 0, 0.66667],
     "107": [0, 0.68889, 0, 0, 0.55556],
+    "160": [0, 0, 0, 0, 0.25],
     "165": [0, 0.675, 0.025, 0, 0.75],
     "174": [0.15559, 0.69224, 0, 0, 0.94666],
     "240": [0, 0.68889, 0, 0, 0.55556],
@@ -1851,16 +1862,7 @@ var metricMap = {
     "57371": [0.13597, 0.63597, 0, 0, 0.77778]
   },
   "Caligraphic-Regular": {
-    "48": [0, 0.43056, 0, 0, 0.5],
-    "49": [0, 0.43056, 0, 0, 0.5],
-    "50": [0, 0.43056, 0, 0, 0.5],
-    "51": [0.19444, 0.43056, 0, 0, 0.5],
-    "52": [0.19444, 0.43056, 0, 0, 0.5],
-    "53": [0.19444, 0.43056, 0, 0, 0.5],
-    "54": [0, 0.64444, 0, 0, 0.5],
-    "55": [0.19444, 0.43056, 0, 0, 0.5],
-    "56": [0, 0.64444, 0, 0, 0.5],
-    "57": [0.19444, 0.43056, 0, 0, 0.5],
+    "32": [0, 0, 0, 0, 0.25],
     "65": [0, 0.68333, 0, 0.19445, 0.79847],
     "66": [0, 0.68333, 0.03041, 0.13889, 0.65681],
     "67": [0, 0.68333, 0.05834, 0.13889, 0.52653],
@@ -1886,9 +1888,11 @@ var metricMap = {
     "87": [0, 0.68333, 0.08222, 0.08334, 0.98778],
     "88": [0, 0.68333, 0.14643, 0.13889, 0.7133],
     "89": [0.09722, 0.68333, 0.08222, 0.08334, 0.66834],
-    "90": [0, 0.68333, 0.07944, 0.13889, 0.72473]
+    "90": [0, 0.68333, 0.07944, 0.13889, 0.72473],
+    "160": [0, 0, 0, 0, 0.25]
   },
   "Fraktur-Regular": {
+    "32": [0, 0, 0, 0, 0.25],
     "33": [0, 0.69141, 0, 0, 0.29574],
     "34": [0, 0.69141, 0, 0, 0.21471],
     "38": [0, 0.69141, 0, 0, 0.73786],
@@ -1970,6 +1974,7 @@ var metricMap = {
     "120": [0.18906, 0.47534, 0, 0, 0.38865],
     "121": [0.18906, 0.47534, 0, 0, 0.49884],
     "122": [0.18906, 0.47534, 0, 0, 0.39054],
+    "160": [0, 0, 0, 0, 0.25],
     "8216": [0, 0.69141, 0, 0, 0.21471],
     "8217": [0, 0.69141, 0, 0, 0.21471],
     "58112": [0, 0.62119, 0, 0, 0.49749],
@@ -1982,6 +1987,7 @@ var metricMap = {
     "58119": [0, 0.47534, 0, 0, 0.50073]
   },
   "Main-Bold": {
+    "32": [0, 0, 0, 0, 0.25],
     "33": [0, 0.69444, 0, 0, 0.35],
     "34": [0, 0.69444, 0, 0, 0.60278],
     "35": [0.19444, 0.69444, 0, 0, 0.95833],
@@ -2075,6 +2081,8 @@ var metricMap = {
     "124": [0.25, 0.75, 0, 0, 0.31944],
     "125": [0.25, 0.75, 0, 0, 0.575],
     "126": [0.35, 0.34444, 0, 0, 0.575],
+    "160": [0, 0, 0, 0, 0.25],
+    "163": [0, 0.69444, 0, 0, 0.86853],
     "168": [0, 0.69444, 0, 0, 0.575],
     "172": [0, 0.44444, 0, 0, 0.76666],
     "176": [0, 0.69444, 0, 0, 0.86944],
@@ -2232,6 +2240,7 @@ var metricMap = {
     "57376": [0.19444, 0.69444, 0, 0, 0]
   },
   "Main-BoldItalic": {
+    "32": [0, 0, 0, 0, 0.25],
     "33": [0, 0.69444, 0.11417, 0, 0.38611],
     "34": [0, 0.69444, 0.07939, 0, 0.62055],
     "35": [0.19444, 0.69444, 0.06833, 0, 0.94444],
@@ -2318,7 +2327,7 @@ var metricMap = {
     "121": [0.19444, 0.44444, 0.105, 0, 0.56166],
     "122": [0, 0.44444, 0.13889, 0, 0.49055],
     "126": [0.35, 0.34444, 0.11472, 0, 0.59111],
-    "163": [0, 0.69444, 0, 0, 0.86853],
+    "160": [0, 0, 0, 0, 0.25],
     "168": [0, 0.69444, 0.11473, 0, 0.59111],
     "176": [0, 0.69444, 0, 0, 0.94888],
     "184": [0.17014, 0, 0, 0, 0.53222],
@@ -2360,6 +2369,7 @@ var metricMap = {
     "8221": [0, 0.69444, 0.07939, 0, 0.62055]
   },
   "Main-Italic": {
+    "32": [0, 0, 0, 0, 0.25],
     "33": [0, 0.69444, 0.12417, 0, 0.30667],
     "34": [0, 0.69444, 0.06961, 0, 0.51444],
     "35": [0.19444, 0.69444, 0.06616, 0, 0.81777],
@@ -2446,7 +2456,7 @@ var metricMap = {
     "121": [0.19444, 0.43056, 0.08847, 0, 0.48555],
     "122": [0, 0.43056, 0.12292, 0, 0.40889],
     "126": [0.35, 0.31786, 0.11585, 0, 0.51111],
-    "163": [0, 0.69444, 0, 0, 0.76909],
+    "160": [0, 0, 0, 0, 0.25],
     "168": [0, 0.66786, 0.10474, 0, 0.51111],
     "176": [0, 0.69444, 0, 0, 0.83129],
     "184": [0.17014, 0, 0, 0, 0.46],
@@ -2455,10 +2465,8 @@ var metricMap = {
     "223": [0.19444, 0.69444, 0.10514, 0, 0.53666],
     "230": [0, 0.43056, 0.07514, 0, 0.71555],
     "248": [0.09722, 0.52778, 0.09194, 0, 0.51111],
-    "305": [0, 0.43056, 0, 0.02778, 0.32246],
     "338": [0, 0.68333, 0.12028, 0, 0.98499],
     "339": [0, 0.43056, 0.07514, 0, 0.71555],
-    "567": [0.19444, 0.43056, 0, 0.08334, 0.38403],
     "710": [0, 0.69444, 0.06646, 0, 0.51111],
     "711": [0, 0.62847, 0.08295, 0, 0.51111],
     "713": [0, 0.56167, 0.10333, 0, 0.51111],
@@ -2584,6 +2592,7 @@ var metricMap = {
     "125": [0.25, 0.75, 0, 0, 0.5],
     "126": [0.35, 0.31786, 0, 0, 0.5],
     "160": [0, 0, 0, 0, 0.25],
+    "163": [0, 0.69444, 0, 0, 0.76909],
     "167": [0.19444, 0.69444, 0, 0, 0.44445],
     "168": [0, 0.66786, 0, 0, 0.5],
     "172": [0, 0.43056, 0, 0, 0.66667],
@@ -2766,6 +2775,17 @@ var metricMap = {
     "57376": [0.19444, 0.69444, 0, 0, 0]
   },
   "Math-BoldItalic": {
+    "32": [0, 0, 0, 0, 0.25],
+    "48": [0, 0.44444, 0, 0, 0.575],
+    "49": [0, 0.44444, 0, 0, 0.575],
+    "50": [0, 0.44444, 0, 0, 0.575],
+    "51": [0.19444, 0.44444, 0, 0, 0.575],
+    "52": [0.19444, 0.44444, 0, 0, 0.575],
+    "53": [0.19444, 0.44444, 0, 0, 0.575],
+    "54": [0, 0.64444, 0, 0, 0.575],
+    "55": [0.19444, 0.44444, 0, 0, 0.575],
+    "56": [0, 0.64444, 0, 0, 0.575],
+    "57": [0.19444, 0.44444, 0, 0, 0.575],
     "65": [0, 0.68611, 0, 0, 0.86944],
     "66": [0, 0.68611, 0.04835, 0, 0.8664],
     "67": [0, 0.68611, 0.06979, 0, 0.81694],
@@ -2818,6 +2838,7 @@ var metricMap = {
     "120": [0, 0.44444, 0, 0, 0.65903],
     "121": [0.19444, 0.44444, 0.03704, 0, 0.59028],
     "122": [0, 0.44444, 0.04213, 0, 0.55509],
+    "160": [0, 0, 0, 0, 0.25],
     "915": [0, 0.68611, 0.15972, 0, 0.65694],
     "916": [0, 0.68611, 0, 0, 0.95833],
     "920": [0, 0.68611, 0.03194, 0, 0.86722],
@@ -2858,9 +2879,22 @@ var metricMap = {
     "981": [0.19444, 0.69444, 0, 0, 0.7125],
     "982": [0, 0.44444, 0.03194, 0, 0.975],
     "1009": [0.19444, 0.44444, 0, 0, 0.6118],
-    "1013": [0, 0.44444, 0, 0, 0.48333]
+    "1013": [0, 0.44444, 0, 0, 0.48333],
+    "57649": [0, 0.44444, 0, 0, 0.39352],
+    "57911": [0.19444, 0.44444, 0, 0, 0.43889]
   },
   "Math-Italic": {
+    "32": [0, 0, 0, 0, 0.25],
+    "48": [0, 0.43056, 0, 0, 0.5],
+    "49": [0, 0.43056, 0, 0, 0.5],
+    "50": [0, 0.43056, 0, 0, 0.5],
+    "51": [0.19444, 0.43056, 0, 0, 0.5],
+    "52": [0.19444, 0.43056, 0, 0, 0.5],
+    "53": [0.19444, 0.43056, 0, 0, 0.5],
+    "54": [0, 0.64444, 0, 0, 0.5],
+    "55": [0.19444, 0.43056, 0, 0, 0.5],
+    "56": [0, 0.64444, 0, 0, 0.5],
+    "57": [0.19444, 0.43056, 0, 0, 0.5],
     "65": [0, 0.68333, 0, 0.13889, 0.75],
     "66": [0, 0.68333, 0.05017, 0.08334, 0.75851],
     "67": [0, 0.68333, 0.07153, 0.08334, 0.71472],
@@ -2913,6 +2947,7 @@ var metricMap = {
     "120": [0, 0.43056, 0, 0.02778, 0.57153],
     "121": [0.19444, 0.43056, 0.03588, 0.05556, 0.49028],
     "122": [0, 0.43056, 0.04398, 0.05556, 0.46505],
+    "160": [0, 0, 0, 0, 0.25],
     "915": [0, 0.68333, 0.13889, 0.08334, 0.61528],
     "916": [0, 0.68333, 0, 0.16667, 0.83334],
     "920": [0, 0.68333, 0.02778, 0.08334, 0.76278],
@@ -2953,104 +2988,12 @@ var metricMap = {
     "981": [0.19444, 0.69444, 0, 0.08334, 0.59583],
     "982": [0, 0.43056, 0.02778, 0, 0.82813],
     "1009": [0.19444, 0.43056, 0, 0.08334, 0.51702],
-    "1013": [0, 0.43056, 0, 0.05556, 0.4059]
-  },
-  "Math-Regular": {
-    "65": [0, 0.68333, 0, 0.13889, 0.75],
-    "66": [0, 0.68333, 0.05017, 0.08334, 0.75851],
-    "67": [0, 0.68333, 0.07153, 0.08334, 0.71472],
-    "68": [0, 0.68333, 0.02778, 0.05556, 0.82792],
-    "69": [0, 0.68333, 0.05764, 0.08334, 0.7382],
-    "70": [0, 0.68333, 0.13889, 0.08334, 0.64306],
-    "71": [0, 0.68333, 0, 0.08334, 0.78625],
-    "72": [0, 0.68333, 0.08125, 0.05556, 0.83125],
-    "73": [0, 0.68333, 0.07847, 0.11111, 0.43958],
-    "74": [0, 0.68333, 0.09618, 0.16667, 0.55451],
-    "75": [0, 0.68333, 0.07153, 0.05556, 0.84931],
-    "76": [0, 0.68333, 0, 0.02778, 0.68056],
-    "77": [0, 0.68333, 0.10903, 0.08334, 0.97014],
-    "78": [0, 0.68333, 0.10903, 0.08334, 0.80347],
-    "79": [0, 0.68333, 0.02778, 0.08334, 0.76278],
-    "80": [0, 0.68333, 0.13889, 0.08334, 0.64201],
-    "81": [0.19444, 0.68333, 0, 0.08334, 0.79056],
-    "82": [0, 0.68333, 0.00773, 0.08334, 0.75929],
-    "83": [0, 0.68333, 0.05764, 0.08334, 0.6132],
-    "84": [0, 0.68333, 0.13889, 0.08334, 0.58438],
-    "85": [0, 0.68333, 0.10903, 0.02778, 0.68278],
-    "86": [0, 0.68333, 0.22222, 0, 0.58333],
-    "87": [0, 0.68333, 0.13889, 0, 0.94445],
-    "88": [0, 0.68333, 0.07847, 0.08334, 0.82847],
-    "89": [0, 0.68333, 0.22222, 0, 0.58056],
-    "90": [0, 0.68333, 0.07153, 0.08334, 0.68264],
-    "97": [0, 0.43056, 0, 0, 0.52859],
-    "98": [0, 0.69444, 0, 0, 0.42917],
-    "99": [0, 0.43056, 0, 0.05556, 0.43276],
-    "100": [0, 0.69444, 0, 0.16667, 0.52049],
-    "101": [0, 0.43056, 0, 0.05556, 0.46563],
-    "102": [0.19444, 0.69444, 0.10764, 0.16667, 0.48959],
-    "103": [0.19444, 0.43056, 0.03588, 0.02778, 0.47697],
-    "104": [0, 0.69444, 0, 0, 0.57616],
-    "105": [0, 0.65952, 0, 0, 0.34451],
-    "106": [0.19444, 0.65952, 0.05724, 0, 0.41181],
-    "107": [0, 0.69444, 0.03148, 0, 0.5206],
-    "108": [0, 0.69444, 0.01968, 0.08334, 0.29838],
-    "109": [0, 0.43056, 0, 0, 0.87801],
-    "110": [0, 0.43056, 0, 0, 0.60023],
-    "111": [0, 0.43056, 0, 0.05556, 0.48472],
-    "112": [0.19444, 0.43056, 0, 0.08334, 0.50313],
-    "113": [0.19444, 0.43056, 0.03588, 0.08334, 0.44641],
-    "114": [0, 0.43056, 0.02778, 0.05556, 0.45116],
-    "115": [0, 0.43056, 0, 0.05556, 0.46875],
-    "116": [0, 0.61508, 0, 0.08334, 0.36111],
-    "117": [0, 0.43056, 0, 0.02778, 0.57246],
-    "118": [0, 0.43056, 0.03588, 0.02778, 0.48472],
-    "119": [0, 0.43056, 0.02691, 0.08334, 0.71592],
-    "120": [0, 0.43056, 0, 0.02778, 0.57153],
-    "121": [0.19444, 0.43056, 0.03588, 0.05556, 0.49028],
-    "122": [0, 0.43056, 0.04398, 0.05556, 0.46505],
-    "915": [0, 0.68333, 0.13889, 0.08334, 0.61528],
-    "916": [0, 0.68333, 0, 0.16667, 0.83334],
-    "920": [0, 0.68333, 0.02778, 0.08334, 0.76278],
-    "923": [0, 0.68333, 0, 0.16667, 0.69445],
-    "926": [0, 0.68333, 0.07569, 0.08334, 0.74236],
-    "928": [0, 0.68333, 0.08125, 0.05556, 0.83125],
-    "931": [0, 0.68333, 0.05764, 0.08334, 0.77986],
-    "933": [0, 0.68333, 0.13889, 0.05556, 0.58333],
-    "934": [0, 0.68333, 0, 0.08334, 0.66667],
-    "936": [0, 0.68333, 0.11, 0.05556, 0.61222],
-    "937": [0, 0.68333, 0.05017, 0.08334, 0.7724],
-    "945": [0, 0.43056, 0.0037, 0.02778, 0.6397],
-    "946": [0.19444, 0.69444, 0.05278, 0.08334, 0.56563],
-    "947": [0.19444, 0.43056, 0.05556, 0, 0.51773],
-    "948": [0, 0.69444, 0.03785, 0.05556, 0.44444],
-    "949": [0, 0.43056, 0, 0.08334, 0.46632],
-    "950": [0.19444, 0.69444, 0.07378, 0.08334, 0.4375],
-    "951": [0.19444, 0.43056, 0.03588, 0.05556, 0.49653],
-    "952": [0, 0.69444, 0.02778, 0.08334, 0.46944],
-    "953": [0, 0.43056, 0, 0.05556, 0.35394],
-    "954": [0, 0.43056, 0, 0, 0.57616],
-    "955": [0, 0.69444, 0, 0, 0.58334],
-    "956": [0.19444, 0.43056, 0, 0.02778, 0.60255],
-    "957": [0, 0.43056, 0.06366, 0.02778, 0.49398],
-    "958": [0.19444, 0.69444, 0.04601, 0.11111, 0.4375],
-    "959": [0, 0.43056, 0, 0.05556, 0.48472],
-    "960": [0, 0.43056, 0.03588, 0, 0.57003],
-    "961": [0.19444, 0.43056, 0, 0.08334, 0.51702],
-    "962": [0.09722, 0.43056, 0.07986, 0.08334, 0.36285],
-    "963": [0, 0.43056, 0.03588, 0, 0.57141],
-    "964": [0, 0.43056, 0.1132, 0.02778, 0.43715],
-    "965": [0, 0.43056, 0.03588, 0.02778, 0.54028],
-    "966": [0.19444, 0.43056, 0, 0.08334, 0.65417],
-    "967": [0.19444, 0.43056, 0, 0.05556, 0.62569],
-    "968": [0.19444, 0.69444, 0.03588, 0.11111, 0.65139],
-    "969": [0, 0.43056, 0.03588, 0, 0.62245],
-    "977": [0, 0.69444, 0, 0.08334, 0.59144],
-    "981": [0.19444, 0.69444, 0, 0.08334, 0.59583],
-    "982": [0, 0.43056, 0.02778, 0, 0.82813],
-    "1009": [0.19444, 0.43056, 0, 0.08334, 0.51702],
-    "1013": [0, 0.43056, 0, 0.05556, 0.4059]
+    "1013": [0, 0.43056, 0, 0.05556, 0.4059],
+    "57649": [0, 0.43056, 0, 0.02778, 0.32246],
+    "57911": [0.19444, 0.43056, 0, 0.08334, 0.38403]
   },
   "SansSerif-Bold": {
+    "32": [0, 0, 0, 0, 0.25],
     "33": [0, 0.69444, 0, 0, 0.36667],
     "34": [0, 0.69444, 0, 0, 0.55834],
     "35": [0.19444, 0.69444, 0, 0, 0.91667],
@@ -3138,6 +3081,7 @@ var metricMap = {
     "121": [0.19444, 0.45833, 0.01528, 0, 0.5],
     "122": [0, 0.45833, 0, 0, 0.47639],
     "126": [0.35, 0.34444, 0, 0, 0.55],
+    "160": [0, 0, 0, 0, 0.25],
     "168": [0, 0.69444, 0, 0, 0.55],
     "176": [0, 0.69444, 0, 0, 0.73334],
     "180": [0, 0.69444, 0, 0, 0.55],
@@ -3171,6 +3115,7 @@ var metricMap = {
     "8221": [0, 0.69444, 0, 0, 0.55834]
   },
   "SansSerif-Italic": {
+    "32": [0, 0, 0, 0, 0.25],
     "33": [0, 0.69444, 0.05733, 0, 0.31945],
     "34": [0, 0.69444, 0.00316, 0, 0.5],
     "35": [0.19444, 0.69444, 0.05087, 0, 0.83334],
@@ -3258,6 +3203,7 @@ var metricMap = {
     "121": [0.19444, 0.44444, 0.10836, 0, 0.46111],
     "122": [0, 0.44444, 0.08752, 0, 0.43472],
     "126": [0.35, 0.32659, 0.08826, 0, 0.5],
+    "160": [0, 0, 0, 0, 0.25],
     "168": [0, 0.67937, 0.06385, 0, 0.5],
     "176": [0, 0.69444, 0, 0, 0.73752],
     "184": [0.17014, 0, 0, 0, 0.44445],
@@ -3292,6 +3238,7 @@ var metricMap = {
     "8221": [0, 0.69444, 0.00316, 0, 0.5]
   },
   "SansSerif-Regular": {
+    "32": [0, 0, 0, 0, 0.25],
     "33": [0, 0.69444, 0, 0, 0.31945],
     "34": [0, 0.69444, 0, 0, 0.5],
     "35": [0.19444, 0.69444, 0, 0, 0.83334],
@@ -3379,6 +3326,7 @@ var metricMap = {
     "121": [0.19444, 0.44444, 0.01389, 0, 0.46111],
     "122": [0, 0.44444, 0, 0, 0.43472],
     "126": [0.35, 0.32659, 0, 0, 0.5],
+    "160": [0, 0, 0, 0, 0.25],
     "168": [0, 0.67937, 0, 0, 0.5],
     "176": [0, 0.69444, 0, 0, 0.66667],
     "184": [0.17014, 0, 0, 0, 0.44445],
@@ -3413,6 +3361,7 @@ var metricMap = {
     "8221": [0, 0.69444, 0, 0, 0.5]
   },
   "Script-Regular": {
+    "32": [0, 0, 0, 0, 0.25],
     "65": [0, 0.7, 0.22925, 0, 0.80253],
     "66": [0, 0.7, 0.04087, 0, 0.90757],
     "67": [0, 0.7, 0.1689, 0, 0.66619],
@@ -3438,9 +3387,11 @@ var metricMap = {
     "87": [0, 0.7, 0.27523, 0, 0.80532],
     "88": [0, 0.7, 0.26006, 0, 0.94445],
     "89": [0, 0.7, 0.2939, 0, 0.70961],
-    "90": [0, 0.7, 0.24037, 0, 0.8212]
+    "90": [0, 0.7, 0.24037, 0, 0.8212],
+    "160": [0, 0, 0, 0, 0.25]
   },
   "Size1-Regular": {
+    "32": [0, 0, 0, 0, 0.25],
     "40": [0.35001, 0.85, 0, 0, 0.45834],
     "41": [0.35001, 0.85, 0, 0, 0.45834],
     "47": [0.35001, 0.85, 0, 0, 0.57778],
@@ -3449,6 +3400,7 @@ var metricMap = {
     "93": [0.35001, 0.85, 0, 0, 0.41667],
     "123": [0.35001, 0.85, 0, 0, 0.58334],
     "125": [0.35001, 0.85, 0, 0, 0.58334],
+    "160": [0, 0, 0, 0, 0.25],
     "710": [0, 0.72222, 0, 0, 0.55556],
     "732": [0, 0.72222, 0, 0, 0.55556],
     "770": [0, 0.72222, 0, 0, 0.55556],
@@ -3486,6 +3438,7 @@ var metricMap = {
     "10758": [0.25001, 0.75, 0, 0, 0.83334]
   },
   "Size2-Regular": {
+    "32": [0, 0, 0, 0, 0.25],
     "40": [0.65002, 1.15, 0, 0, 0.59722],
     "41": [0.65002, 1.15, 0, 0, 0.59722],
     "47": [0.65002, 1.15, 0, 0, 0.81111],
@@ -3494,6 +3447,7 @@ var metricMap = {
     "93": [0.65002, 1.15, 0, 0, 0.47222],
     "123": [0.65002, 1.15, 0, 0, 0.66667],
     "125": [0.65002, 1.15, 0, 0, 0.66667],
+    "160": [0, 0, 0, 0, 0.25],
     "710": [0, 0.75, 0, 0, 1.0],
     "732": [0, 0.75, 0, 0, 1.0],
     "770": [0, 0.75, 0, 0, 1.0],
@@ -3523,6 +3477,7 @@ var metricMap = {
     "10758": [0.55001, 1.05, 0, 0, 1.11111]
   },
   "Size3-Regular": {
+    "32": [0, 0, 0, 0, 0.25],
     "40": [0.95003, 1.45, 0, 0, 0.73611],
     "41": [0.95003, 1.45, 0, 0, 0.73611],
     "47": [0.95003, 1.45, 0, 0, 1.04445],
@@ -3531,6 +3486,7 @@ var metricMap = {
     "93": [0.95003, 1.45, 0, 0, 0.52778],
     "123": [0.95003, 1.45, 0, 0, 0.75],
     "125": [0.95003, 1.45, 0, 0, 0.75],
+    "160": [0, 0, 0, 0, 0.25],
     "710": [0, 0.75, 0, 0, 1.44445],
     "732": [0, 0.75, 0, 0, 1.44445],
     "770": [0, 0.75, 0, 0, 1.44445],
@@ -3544,6 +3500,7 @@ var metricMap = {
     "10217": [0.95003, 1.45, 0, 0, 0.75]
   },
   "Size4-Regular": {
+    "32": [0, 0, 0, 0, 0.25],
     "40": [1.25003, 1.75, 0, 0, 0.79167],
     "41": [1.25003, 1.75, 0, 0, 0.79167],
     "47": [1.25003, 1.75, 0, 0, 1.27778],
@@ -3552,6 +3509,7 @@ var metricMap = {
     "93": [1.25003, 1.75, 0, 0, 0.58334],
     "123": [1.25003, 1.75, 0, 0, 0.80556],
     "125": [1.25003, 1.75, 0, 0, 0.80556],
+    "160": [0, 0, 0, 0, 0.25],
     "710": [0, 0.825, 0, 0, 1.8889],
     "732": [0, 0.825, 0, 0, 1.8889],
     "770": [0, 0.825, 0, 0, 1.8889],
@@ -4256,9 +4214,10 @@ defineSymbol(math, ams, textord, "\u25a0", "\\blacksquare");
 defineSymbol(math, ams, textord, "\u29eb", "\\blacklozenge");
 defineSymbol(math, ams, textord, "\u2605", "\\bigstar");
 defineSymbol(math, ams, textord, "\u2222", "\\sphericalangle", true);
-defineSymbol(math, ams, textord, "\u2201", "\\complement", true); // unicode-math maps U+F0 (ð) to \matheth. We map to AMS function \eth
+defineSymbol(math, ams, textord, "\u2201", "\\complement", true); // unicode-math maps U+F0 to \matheth. We map to AMS function \eth
 
 defineSymbol(math, ams, textord, "\u00f0", "\\eth", true);
+defineSymbol(text$1, main, textord, "\u00f0", "\u00f0");
 defineSymbol(math, ams, textord, "\u2571", "\\diagup");
 defineSymbol(math, ams, textord, "\u2572", "\\diagdown");
 defineSymbol(math, ams, textord, "\u25a1", "\\square");
@@ -4277,10 +4236,10 @@ defineSymbol(math, ams, textord, "\u2137", "\\gimel", true); // AMS Greek
 defineSymbol(math, ams, textord, "\u03dd", "\\digamma", true);
 defineSymbol(math, ams, textord, "\u03f0", "\\varkappa"); // AMS Delimiters
 
-defineSymbol(math, ams, open, "\u250c", "\\ulcorner", true);
-defineSymbol(math, ams, close, "\u2510", "\\urcorner", true);
-defineSymbol(math, ams, open, "\u2514", "\\llcorner", true);
-defineSymbol(math, ams, close, "\u2518", "\\lrcorner", true); // AMS Binary Relations
+defineSymbol(math, ams, open, "\u250c", "\\@ulcorner", true);
+defineSymbol(math, ams, close, "\u2510", "\\@urcorner", true);
+defineSymbol(math, ams, open, "\u2514", "\\@llcorner", true);
+defineSymbol(math, ams, close, "\u2518", "\\@lrcorner", true); // AMS Binary Relations
 
 defineSymbol(math, ams, rel, "\u2266", "\\leqq", true);
 defineSymbol(math, ams, rel, "\u2a7d", "\\leqslant", true);
@@ -4508,28 +4467,22 @@ defineSymbol(math, main, bin, "\u2228", "\\lor");
 defineSymbol(math, main, bin, "\u2227", "\\wedge", true);
 defineSymbol(math, main, bin, "\u2228", "\\vee", true);
 defineSymbol(math, main, textord, "\u221a", "\\surd");
-defineSymbol(math, main, open, "(", "(");
-defineSymbol(math, main, open, "[", "[");
 defineSymbol(math, main, open, "\u27e8", "\\langle", true);
 defineSymbol(math, main, open, "\u2223", "\\lvert");
 defineSymbol(math, main, open, "\u2225", "\\lVert");
-defineSymbol(math, main, close, ")", ")");
-defineSymbol(math, main, close, "]", "]");
 defineSymbol(math, main, close, "?", "?");
 defineSymbol(math, main, close, "!", "!");
 defineSymbol(math, main, close, "\u27e9", "\\rangle", true);
 defineSymbol(math, main, close, "\u2223", "\\rvert");
 defineSymbol(math, main, close, "\u2225", "\\rVert");
 defineSymbol(math, main, rel, "=", "=");
-defineSymbol(math, main, rel, "<", "<");
-defineSymbol(math, main, rel, ">", ">");
 defineSymbol(math, main, rel, ":", ":");
 defineSymbol(math, main, rel, "\u2248", "\\approx", true);
 defineSymbol(math, main, rel, "\u2245", "\\cong", true);
 defineSymbol(math, main, rel, "\u2265", "\\ge");
 defineSymbol(math, main, rel, "\u2265", "\\geq", true);
 defineSymbol(math, main, rel, "\u2190", "\\gets");
-defineSymbol(math, main, rel, ">", "\\gt");
+defineSymbol(math, main, rel, ">", "\\gt", true);
 defineSymbol(math, main, rel, "\u2208", "\\in", true);
 defineSymbol(math, main, rel, "\ue020", "\\@not");
 defineSymbol(math, main, rel, "\u2282", "\\subset", true);
@@ -4542,7 +4495,7 @@ defineSymbol(math, main, rel, "\u22a8", "\\models");
 defineSymbol(math, main, rel, "\u2190", "\\leftarrow", true);
 defineSymbol(math, main, rel, "\u2264", "\\le");
 defineSymbol(math, main, rel, "\u2264", "\\leq", true);
-defineSymbol(math, main, rel, "<", "\\lt");
+defineSymbol(math, main, rel, "<", "\\lt", true);
 defineSymbol(math, main, rel, "\u2192", "\\rightarrow", true);
 defineSymbol(math, main, rel, "\u2192", "\\to");
 defineSymbol(math, ams, rel, "\u2271", "\\ngeq", true);
@@ -4553,6 +4506,7 @@ defineSymbol(math, main, spacing, "\u00a0", "\\space"); // Ref: LaTeX Source 2e:
 
 defineSymbol(math, main, spacing, "\u00a0", "\\nobreakspace");
 defineSymbol(text$1, main, spacing, "\u00a0", "\\ ");
+defineSymbol(text$1, main, spacing, "\u00a0", " ");
 defineSymbol(text$1, main, spacing, "\u00a0", "~");
 defineSymbol(text$1, main, spacing, "\u00a0", "\\space");
 defineSymbol(text$1, main, spacing, "\u00a0", "\\nobreakspace");
@@ -4584,15 +4538,15 @@ defineSymbol(text$1, main, textord, "}", "\\}");
 defineSymbol(text$1, main, textord, "}", "\\textbraceright");
 defineSymbol(math, main, open, "{", "\\lbrace");
 defineSymbol(math, main, close, "}", "\\rbrace");
-defineSymbol(math, main, open, "[", "\\lbrack");
-defineSymbol(text$1, main, textord, "[", "\\lbrack");
-defineSymbol(math, main, close, "]", "\\rbrack");
-defineSymbol(text$1, main, textord, "]", "\\rbrack");
-defineSymbol(math, main, open, "(", "\\lparen");
-defineSymbol(math, main, close, ")", "\\rparen");
-defineSymbol(text$1, main, textord, "<", "\\textless"); // in T1 fontenc
+defineSymbol(math, main, open, "[", "\\lbrack", true);
+defineSymbol(text$1, main, textord, "[", "\\lbrack", true);
+defineSymbol(math, main, close, "]", "\\rbrack", true);
+defineSymbol(text$1, main, textord, "]", "\\rbrack", true);
+defineSymbol(math, main, open, "(", "\\lparen", true);
+defineSymbol(math, main, close, ")", "\\rparen", true);
+defineSymbol(text$1, main, textord, "<", "\\textless", true); // in T1 fontenc
 
-defineSymbol(text$1, main, textord, ">", "\\textgreater"); // in T1 fontenc
+defineSymbol(text$1, main, textord, ">", "\\textgreater", true); // in T1 fontenc
 
 defineSymbol(math, main, open, "\u230a", "\\lfloor", true);
 defineSymbol(math, main, close, "\u230b", "\\rfloor", true);
@@ -4601,7 +4555,7 @@ defineSymbol(math, main, close, "\u2309", "\\rceil", true);
 defineSymbol(math, main, textord, "\\", "\\backslash");
 defineSymbol(math, main, textord, "\u2223", "|");
 defineSymbol(math, main, textord, "\u2223", "\\vert");
-defineSymbol(text$1, main, textord, "|", "\\textbar"); // in T1 fontenc
+defineSymbol(text$1, main, textord, "|", "\\textbar", true); // in T1 fontenc
 
 defineSymbol(math, main, textord, "\u2225", "\\|");
 defineSymbol(math, main, textord, "\u2225", "\\Vert");
@@ -4631,8 +4585,6 @@ defineSymbol(math, main, op, "\u2a02", "\\bigotimes");
 defineSymbol(math, main, op, "\u2a01", "\\bigoplus");
 defineSymbol(math, main, op, "\u2a00", "\\bigodot");
 defineSymbol(math, main, op, "\u222e", "\\oint");
-defineSymbol(math, main, op, "\u222f", "\\oiint");
-defineSymbol(math, main, op, "\u2230", "\\oiiint");
 defineSymbol(math, main, op, "\u2a06", "\\bigsqcup");
 defineSymbol(math, main, op, "\u222b", "\\smallint");
 defineSymbol(text$1, main, inner, "\u2026", "\\textellipsis");
@@ -4653,14 +4605,16 @@ defineSymbol(math, main, accent, "\u02c7", "\\check");
 defineSymbol(math, main, accent, "\u005e", "\\hat");
 defineSymbol(math, main, accent, "\u20d7", "\\vec");
 defineSymbol(math, main, accent, "\u02d9", "\\dot");
-defineSymbol(math, main, accent, "\u02da", "\\mathring");
-defineSymbol(math, main, mathord, "\u0131", "\\imath", true);
-defineSymbol(math, main, mathord, "\u0237", "\\jmath", true);
+defineSymbol(math, main, accent, "\u02da", "\\mathring"); // \imath and \jmath should be invariant to \mathrm, \mathbf, etc., so use PUA
+
+defineSymbol(math, main, mathord, "\ue131", "\\@imath");
+defineSymbol(math, main, mathord, "\ue237", "\\@jmath");
+defineSymbol(math, main, textord, "\u0131", "\u0131");
+defineSymbol(math, main, textord, "\u0237", "\u0237");
 defineSymbol(text$1, main, textord, "\u0131", "\\i", true);
 defineSymbol(text$1, main, textord, "\u0237", "\\j", true);
 defineSymbol(text$1, main, textord, "\u00df", "\\ss", true);
 defineSymbol(text$1, main, textord, "\u00e6", "\\ae", true);
-defineSymbol(text$1, main, textord, "\u00e6", "\\ae", true);
 defineSymbol(text$1, main, textord, "\u0153", "\\oe", true);
 defineSymbol(text$1, main, textord, "\u00f8", "\\o", true);
 defineSymbol(text$1, main, textord, "\u00c6", "\\AE", true);
@@ -4697,34 +4651,31 @@ const ligatures = {
   "``": true,
   "''": true
 };
-defineSymbol(text$1, main, textord, "\u2013", "--");
+defineSymbol(text$1, main, textord, "\u2013", "--", true);
 defineSymbol(text$1, main, textord, "\u2013", "\\textendash");
-defineSymbol(text$1, main, textord, "\u2014", "---");
+defineSymbol(text$1, main, textord, "\u2014", "---", true);
 defineSymbol(text$1, main, textord, "\u2014", "\\textemdash");
-defineSymbol(text$1, main, textord, "\u2018", "`");
+defineSymbol(text$1, main, textord, "\u2018", "`", true);
 defineSymbol(text$1, main, textord, "\u2018", "\\textquoteleft");
-defineSymbol(text$1, main, textord, "\u2019", "'");
+defineSymbol(text$1, main, textord, "\u2019", "'", true);
 defineSymbol(text$1, main, textord, "\u2019", "\\textquoteright");
-defineSymbol(text$1, main, textord, "\u201c", "``");
+defineSymbol(text$1, main, textord, "\u201c", "``", true);
 defineSymbol(text$1, main, textord, "\u201c", "\\textquotedblleft");
-defineSymbol(text$1, main, textord, "\u201d", "''");
+defineSymbol(text$1, main, textord, "\u201d", "''", true);
 defineSymbol(text$1, main, textord, "\u201d", "\\textquotedblright"); //  \degree from gensymb package
 
 defineSymbol(math, main, textord, "\u00b0", "\\degree", true);
 defineSymbol(text$1, main, textord, "\u00b0", "\\degree"); // \textdegree from inputenc package
 
 defineSymbol(text$1, main, textord, "\u00b0", "\\textdegree", true); // TODO: In LaTeX, \pounds can generate a different character in text and math
-// mode, but among our fonts, only Main-Italic defines this character "163".
+// mode, but among our fonts, only Main-Regular defines this character "163".
 
-defineSymbol(math, main, mathord, "\u00a3", "\\pounds");
-defineSymbol(math, main, mathord, "\u00a3", "\\mathsterling", true);
-defineSymbol(text$1, main, mathord, "\u00a3", "\\pounds");
-defineSymbol(text$1, main, mathord, "\u00a3", "\\textsterling", true);
+defineSymbol(math, main, textord, "\u00a3", "\\pounds");
+defineSymbol(math, main, textord, "\u00a3", "\\mathsterling", true);
+defineSymbol(text$1, main, textord, "\u00a3", "\\pounds");
+defineSymbol(text$1, main, textord, "\u00a3", "\\textsterling", true);
 defineSymbol(math, ams, textord, "\u2720", "\\maltese");
-defineSymbol(text$1, ams, textord, "\u2720", "\\maltese");
-defineSymbol(text$1, main, spacing, "\u00a0", "\\ ");
-defineSymbol(text$1, main, spacing, "\u00a0", " ");
-defineSymbol(text$1, main, spacing, "\u00a0", "~"); // There are lots of symbols which are the same, so we add them in afterwards.
+defineSymbol(text$1, ams, textord, "\u2720", "\\maltese"); // There are lots of symbols which are the same, so we add them in afterwards.
 // All of these are textords in math mode
 
 const mathTextSymbols = "0123456789/@.\"";
@@ -4735,7 +4686,7 @@ for (let i = 0; i < mathTextSymbols.length; i++) {
 } // All of these are textords in text mode
 
 
-const textSymbols = "0123456789!@*()-=+[]<>|\";:?/.,";
+const textSymbols = "0123456789!@*()-=+\";:?/.,";
 
 for (let i = 0; i < textSymbols.length; i++) {
   const ch = textSymbols.charAt(i);
@@ -4860,7 +4811,7 @@ for (let i = 0; i < 10; i++) {
 // TODO(edemaine): Fix this.
 
 
-const extraLatin = "ÇÐÞçþ";
+const extraLatin = "\u00c7\u00d0\u00de\u00e7\u00fe";
 
 for (let i = 0; i < extraLatin.length; i++) {
   const ch = extraLatin.charAt(i);
@@ -4868,15 +4819,6 @@ for (let i = 0; i < extraLatin.length; i++) {
   defineSymbol(text$1, main, textord, ch, ch);
 }
 
-defineSymbol(text$1, main, textord, "ð", "ð"); // Unicode versions of existing characters
-
-defineSymbol(text$1, main, textord, "\u2013", "–");
-defineSymbol(text$1, main, textord, "\u2014", "—");
-defineSymbol(text$1, main, textord, "\u2018", "‘");
-defineSymbol(text$1, main, textord, "\u2019", "’");
-defineSymbol(text$1, main, textord, "\u201c", "“");
-defineSymbol(text$1, main, textord, "\u201d", "”");
-
 /**
  * This file provides support for Unicode range U+1D400 to U+1D7FF,
  * Mathematical Alphanumeric Symbols.
@@ -4896,8 +4838,8 @@ defineSymbol(text$1, main, textord, "\u201d", "”");
 
 const wideLatinLetterData = [["mathbf", "textbf", "Main-Bold"], // A-Z bold upright
 ["mathbf", "textbf", "Main-Bold"], // a-z bold upright
-["mathdefault", "textit", "Math-Italic"], // A-Z italic
-["mathdefault", "textit", "Math-Italic"], // a-z italic
+["mathnormal", "textit", "Math-Italic"], // A-Z italic
+["mathnormal", "textit", "Math-Italic"], // a-z italic
 ["boldsymbol", "boldsymbol", "Main-BoldItalic"], // A-Z bold italic
 ["boldsymbol", "boldsymbol", "Main-BoldItalic"], // a-z bold italic
 // Map fancy A-Z letters to script, not calligraphic.
@@ -5378,15 +5320,11 @@ const calculateSize = function calculateSize(sizeValue, options) {
 };
 
 /* eslint no-console:0 */
-// The following have to be loaded from Main-Italic font, using class mathit
-const mathitLetters = ["\\imath", "ı", // dotless i
-"\\jmath", "ȷ", // dotless j
-"\\pounds", "\\mathsterling", "\\textsterling", "£"];
+
 /**
  * Looks up the given symbol in fontMetrics, after applying any symbol
  * replacements defined in symbol.js
  */
-
 const lookupSymbol = function lookupSymbol(value, // TODO(#963): Use a union type for this.
 fontName, mode) {
   // Replace the value with its replaced value from symbol.js
@@ -5473,54 +5411,6 @@ const mathsym = function mathsym(value, mode, options, classes) {
     return makeSymbol(value, "AMS-Regular", mode, options, classes.concat(["amsrm"]));
   }
 };
-/**
- * Determines which of the two font names (Main-Italic and Math-Italic) and
- * corresponding style tags (maindefault or mathit) to use for default math font,
- * depending on the symbol.
- */
-
-
-const mathdefault = function mathdefault(value, mode, options, classes) {
-  if (/[0-9]/.test(value.charAt(0)) || // glyphs for \imath and \jmath do not exist in Math-Italic so we
-  // need to use Main-Italic instead
-  utils.contains(mathitLetters, value)) {
-    return {
-      fontName: "Main-Italic",
-      fontClass: "mathit"
-    };
-  } else {
-    return {
-      fontName: "Math-Italic",
-      fontClass: "mathdefault"
-    };
-  }
-};
-/**
- * Determines which of the font names (Main-Italic, Math-Italic, and Caligraphic)
- * and corresponding style tags (mathit, mathdefault, or mathcal) to use for font
- * "mathnormal", depending on the symbol.  Use this function instead of fontMap for
- * font "mathnormal".
- */
-
-
-const mathnormal = function mathnormal(value, mode, options, classes) {
-  if (utils.contains(mathitLetters, value)) {
-    return {
-      fontName: "Main-Italic",
-      fontClass: "mathit"
-    };
-  } else if (/[0-9]/.test(value.charAt(0))) {
-    return {
-      fontName: "Caligraphic-Regular",
-      fontClass: "mathcal"
-    };
-  } else {
-    return {
-      fontName: "Math-Italic",
-      fontClass: "mathdefault"
-    };
-  }
-};
 /**
  * Determines which of the two font names (Main-Bold and Math-BoldItalic) and
  * corresponding style tags (mathbf or boldsymbol) to use for font "boldsymbol",
@@ -5529,8 +5419,8 @@ const mathnormal = function mathnormal(value, mode, options, classes) {
  */
 
 
-const boldsymbol = function boldsymbol(value, mode, options, classes) {
-  if (lookupSymbol(value, "Math-BoldItalic", mode).metrics) {
+const boldsymbol = function boldsymbol(value, mode, options, classes, type) {
+  if (type !== "textord" && lookupSymbol(value, "Math-BoldItalic", mode).metrics) {
     return {
       fontName: "Math-BoldItalic",
       fontClass: "boldsymbol"
@@ -5568,13 +5458,10 @@ const makeOrd = function makeOrd(group, options, type) {
     let fontName;
     let fontClasses;
 
-    if (fontOrFamily === "boldsymbol" || fontOrFamily === "mathnormal") {
-      const fontData = fontOrFamily === "boldsymbol" ? boldsymbol(text, mode, options, classes) : mathnormal(text, mode, options, classes);
+    if (fontOrFamily === "boldsymbol") {
+      const fontData = boldsymbol(text, mode, options, classes, type);
       fontName = fontData.fontName;
       fontClasses = [fontData.fontClass];
-    } else if (utils.contains(mathitLetters, text)) {
-      fontName = "Main-Italic";
-      fontClasses = ["mathit"];
     } else if (isFont) {
       fontName = fontMap[fontOrFamily].fontName;
       fontClasses = [fontOrFamily];
@@ -5599,8 +5486,7 @@ const makeOrd = function makeOrd(group, options, type) {
 
 
   if (type === "mathord") {
-    const fontLookup = mathdefault(text, mode, options, classes);
-    return makeSymbol(text, fontLookup.fontName, mode, options, classes.concat([fontLookup.fontClass]));
+    return makeSymbol(text, "Math-Italic", mode, options, classes.concat(["mathnormal"]));
   } else if (type === "textord") {
     const font = symbols[mode][text] && symbols[mode][text].font;
 
@@ -6012,12 +5898,13 @@ const fontMap = {
     variant: "italic",
     fontName: "Main-Italic"
   },
-  // Default math font, "mathnormal" and "boldsymbol" are missing because they
-  // require the use of several fonts: Main-Italic and Math-Italic for default
-  // math font, Main-Italic, Math-Italic, Caligraphic for "mathnormal", and
-  // Math-BoldItalic and Main-Bold for "boldsymbol".  This is handled by a
-  // special case in makeOrd which ends up calling mathdefault, mathnormal,
-  // and boldsymbol.
+  "mathnormal": {
+    variant: "italic",
+    fontName: "Math-Italic"
+  },
+  // "boldsymbol" is missing because they require the use of multiple fonts:
+  // Math-BoldItalic and Main-Bold.  This is handled by a special case in
+  // makeOrd which ends up calling boldsymbol.
   // families
   "mathbb": {
     variant: "double-struck",
@@ -6052,7 +5939,9 @@ const svgData = {
   // oval to overlay the integrand
   oiintSize2: ["oiintSize2", 1.472, 0.659],
   oiiintSize1: ["oiiintSize1", 1.304, 0.499],
-  oiiintSize2: ["oiiintSize2", 1.98, 0.659]
+  oiiintSize2: ["oiiintSize2", 1.98, 0.659],
+  leftParenInner: ["leftParenInner", 0.875, 0.3],
+  rightParenInner: ["rightParenInner", 0.875, 0.3]
 };
 
 const staticSvg = function staticSvg(value, options) {
@@ -6095,86 +5984,6 @@ var buildCommon = {
   tryCombineChars
 };
 
-/**
- * Asserts that the node is of the given type and returns it with stricter
- * typing. Throws if the node's type does not match.
- */
-function assertNodeType(node, type) {
-  const typedNode = checkNodeType(node, type);
-
-  if (!typedNode) {
-    throw new Error(`Expected node of type ${type}, but got ` + (node ? `node of type ${node.type}` : String(node)));
-  } // $FlowFixMe: Unsure why.
-
-
-  return typedNode;
-}
-/**
- * Returns the node more strictly typed iff it is of the given type. Otherwise,
- * returns null.
- */
-
-function checkNodeType(node, type) {
-  if (node && node.type === type) {
-    // The definition of ParseNode<TYPE> doesn't communicate to flow that
-    // `type: TYPE` (as that's not explicitly mentioned anywhere), though that
-    // happens to be true for all our value types.
-    // $FlowFixMe
-    return node;
-  }
-
-  return null;
-}
-/**
- * Asserts that the node is of the given type and returns it with stricter
- * typing. Throws if the node's type does not match.
- */
-
-function assertAtomFamily(node, family) {
-  const typedNode = checkAtomFamily(node, family);
-
-  if (!typedNode) {
-    throw new Error(`Expected node of type "atom" and family "${family}", but got ` + (node ? node.type === "atom" ? `atom of family ${node.family}` : `node of type ${node.type}` : String(node)));
-  }
-
-  return typedNode;
-}
-/**
- * Returns the node more strictly typed iff it is of the given type. Otherwise,
- * returns null.
- */
-
-function checkAtomFamily(node, family) {
-  return node && node.type === "atom" && node.family === family ? node : null;
-}
-/**
- * Returns the node more strictly typed iff it is of the given type. Otherwise,
- * returns null.
- */
-
-function assertSymbolNodeType(node) {
-  const typedNode = checkSymbolNodeType(node);
-
-  if (!typedNode) {
-    throw new Error(`Expected node of symbol group type, but got ` + (node ? `node of type ${node.type}` : String(node)));
-  }
-
-  return typedNode;
-}
-/**
- * Returns the node more strictly typed iff it is of the given type. Otherwise,
- * returns null.
- */
-
-function checkSymbolNodeType(node) {
-  if (node && (node.type === "atom" || NON_ATOMS.hasOwnProperty(node.type))) {
-    // $FlowFixMe
-    return node;
-  }
-
-  return null;
-}
-
 /**
  * Describes spaces between different classes of atoms.
  */
@@ -6268,6 +6077,21 @@ const tightSpacings = {
   }
 };
 
+/** Context provided to function handlers for error messages. */
+// Note: reverse the order of the return type union will cause a flow error.
+// See https://github.com/facebook/flow/issues/3663.
+// More general version of `HtmlBuilder` for nodes (e.g. \sum, accent types)
+// whose presence impacts super/subscripting. In this case, ParseNode<"supsub">
+// delegates its HTML building to the HtmlBuilder corresponding to these nodes.
+
+/**
+ * Final function spec for use at parse time.
+ * This is almost identical to `FunctionPropSpec`, except it
+ * 1. includes the function handler, and
+ * 2. requires all arguments except argTypes.
+ * It is generated by `defineFunction()` below.
+ */
+
 /**
  * All registered functions.
  * `functions.js` just exports this same dictionary again and makes it public.
@@ -6348,8 +6172,7 @@ function defineFunctionBuilders(_ref2) {
 // list of elements, we normalize for different kinds of arguments
 
 const ordargument = function ordargument(arg) {
-  const node = checkNodeType(arg, "ordgroup");
-  return node ? node.body : [arg];
+  return arg.type === "ordgroup" ? arg.body : [arg];
 };
 
 /**
@@ -6417,9 +6240,9 @@ const buildExpression = function buildExpression(expression, options, isRealGrou
   let glueOptions = options;
 
   if (expression.length === 1) {
-    const node = checkNodeType(expression[0], "sizing") || checkNodeType(expression[0], "styling");
+    const node = expression[0];
 
-    if (!node) ; else if (node.type === "sizing") {
+    if (node.type === "sizing") {
       glueOptions = options.havingSize(node.size);
     } else if (node.type === "styling") {
       glueOptions = options.havingStyle(styleMap[node.style]);
@@ -6436,6 +6259,7 @@ const buildExpression = function buildExpression(expression, options, isRealGrou
   // Before determining what spaces to insert, perform bin cancellation.
   // Binary operators change to ordinary symbols in some contexts.
 
+  const isRoot = isRealGroup === "root";
   traverseNonSpaceNodes(groups, (node, prev) => {
     const prevType = prev.classes[0];
     const type = node.classes[0];
@@ -6447,7 +6271,7 @@ const buildExpression = function buildExpression(expression, options, isRealGrou
     }
   }, {
     node: dummyPrev
-  }, dummyNext);
+  }, dummyNext, isRoot);
   traverseNonSpaceNodes(groups, (node, prev) => {
     const prevType = getTypeOfDomTree(prev);
     const type = getTypeOfDomTree(node); // 'mtight' indicates that the node is script or scriptscript style.
@@ -6460,7 +6284,7 @@ const buildExpression = function buildExpression(expression, options, isRealGrou
     }
   }, {
     node: dummyPrev
-  }, dummyNext);
+  }, dummyNext, isRoot);
   return groups;
 }; // Depth-first traverse non-space `nodes`, calling `callback` with the current and
 // previous node as arguments, optionally returning a node to insert after the
@@ -6468,7 +6292,7 @@ const buildExpression = function buildExpression(expression, options, isRealGrou
 // function to insert after it. `next` is a node that will be added to the right.
 // Used for bin cancellation and inserting spacings.
 
-const traverseNonSpaceNodes = function traverseNonSpaceNodes(nodes, callback, prev, next) {
+const traverseNonSpaceNodes = function traverseNonSpaceNodes(nodes, callback, prev, next, isRoot) {
   if (next) {
     // temporarily append the right node, if exists
     nodes.push(next);
@@ -6483,29 +6307,33 @@ const traverseNonSpaceNodes = function traverseNonSpaceNodes(nodes, callback, pr
     if (partialGroup) {
       // Recursive DFS
       // $FlowFixMe: make nodes a $ReadOnlyArray by returning a new array
-      traverseNonSpaceNodes(partialGroup.children, callback, prev);
+      traverseNonSpaceNodes(partialGroup.children, callback, prev, null, isRoot);
       continue;
     } // Ignore explicit spaces (e.g., \;, \,) when determining what implicit
     // spacing should go between atoms of different classes
 
 
-    if (node.classes[0] === "mspace") {
-      continue;
-    }
+    const nonspace = !node.hasClass("mspace");
 
-    const result = callback(node, prev.node);
+    if (nonspace) {
+      const result = callback(node, prev.node);
 
-    if (result) {
-      if (prev.insertAfter) {
-        prev.insertAfter(result);
-      } else {
-        // insert at front
-        nodes.unshift(result);
-        i++;
+      if (result) {
+        if (prev.insertAfter) {
+          prev.insertAfter(result);
+        } else {
+          // insert at front
+          nodes.unshift(result);
+          i++;
+        }
       }
     }
 
-    prev.node = node;
+    if (nonspace) {
+      prev.node = node;
+    } else if (isRoot && node.hasClass("newline")) {
+      prev.node = makeSpan$1(["leftmost"]); // treat like beginning of line
+    }
 
     prev.insertAfter = (index => n => {
       nodes.splice(index + 1, 0, n);
@@ -6520,7 +6348,7 @@ const traverseNonSpaceNodes = function traverseNonSpaceNodes(nodes, callback, pr
 
 
 const checkPartialGroup = function checkPartialGroup(node) {
-  if (node instanceof DocumentFragment || node instanceof Anchor) {
+  if (node instanceof DocumentFragment || node instanceof Anchor || node instanceof Span && node.hasClass("enclosing")) {
     return node;
   }
 
@@ -6605,10 +6433,6 @@ function buildHTMLUnbreakable(children, options) {
   const body = makeSpan$1(["base"], children, options); // Add strut, which ensures that the top of the HTML element falls at
   // the height of the expression, and the bottom of the HTML element
   // falls at the depth of the expression.
-  // We used to have separate top and bottom struts, where the bottom strut
-  // would like to use `vertical-align: top`, but in IE 9 this lowers the
-  // baseline of the box to the bottom of this strut (instead of staying in
-  // the normal place) so we use an absolute value for vertical-align instead.
 
   const strut = makeSpan$1(["strut"]);
   strut.style.height = body.height + body.depth + "em";
@@ -6632,7 +6456,7 @@ function buildHTML(tree, options) {
   } // Build the expression contained in the tree
 
 
-  const expression = buildExpression(tree, options, true);
+  const expression = buildExpression(tree, options, "root");
   const children = []; // Create one base node for each chunk between potential line breaks.
   // The TeXBook [p.173] says "A formula will be broken only after a
   // relation symbol like $=$ or $<$ or $\rightarrow$, or after a binary
@@ -6993,7 +6817,7 @@ const getVariant = function getVariant(group, options) {
   if (font === "mathit") {
     return "italic";
   } else if (font === "boldsymbol") {
-    return "bold-italic";
+    return group.type === "textord" ? "bold" : "bold-italic";
   } else if (font === "mathbf") {
     return "bold";
   } else if (font === "mathbb") {
@@ -7124,7 +6948,7 @@ const buildGroup$1 = function buildGroup(group, options) {
  * we can do appropriate styling.
  */
 
-function buildMathML(tree, texExpression, options, forMathmlOnly) {
+function buildMathML(tree, texExpression, options, isDisplayMode, forMathmlOnly) {
   const expression = buildExpression$1(tree, options); // Wrap up the expression in an mrow so it is presented in the semantics
   // tag correctly, unless it's a single <mrow> or <mtable>.
 
@@ -7141,11 +6965,16 @@ function buildMathML(tree, texExpression, options, forMathmlOnly) {
   annotation.setAttribute("encoding", "application/x-tex");
   const semantics = new mathMLTree.MathNode("semantics", [wrapper, annotation]);
   const math = new mathMLTree.MathNode("math", [semantics]);
-  math.setAttribute("xmlns", "http://www.w3.org/1998/Math/MathML"); // You can't style <math> nodes, so we wrap the node in a span.
+  math.setAttribute("xmlns", "http://www.w3.org/1998/Math/MathML");
+
+  if (isDisplayMode) {
+    math.setAttribute("display", "block");
+  } // You can't style <math> nodes, so we wrap the node in a span.
   // NOTE: The span class is not typed to have <math> nodes as children, and
   // we don't want to make the children type more generic since the children
   // of span are expected to have more fields in `buildHtml` contexts.
 
+
   const wrapperClass = forMathmlOnly ? "katex" : "katex-mathml"; // $FlowFixMe
 
   return buildCommon.makeSpan([wrapperClass], [math]);
@@ -7182,12 +7011,12 @@ const buildTree = function buildTree(tree, expression, settings) {
   let katexNode;
 
   if (settings.output === "mathml") {
-    return buildMathML(tree, expression, options, true);
+    return buildMathML(tree, expression, options, settings.displayMode, true);
   } else if (settings.output === "html") {
     const htmlNode = buildHTML(tree, options);
     katexNode = buildCommon.makeSpan(["katex"], [htmlNode]);
   } else {
-    const mathMLNode = buildMathML(tree, expression, options, false);
+    const mathMLNode = buildMathML(tree, expression, options, settings.displayMode, false);
     const htmlNode = buildHTML(tree, options);
     katexNode = buildCommon.makeSpan(["katex"], [mathMLNode, htmlNode]);
   }
@@ -7537,15 +7366,53 @@ var stretchy = {
   svgSpan
 };
 
+/**
+ * Asserts that the node is of the given type and returns it with stricter
+ * typing. Throws if the node's type does not match.
+ */
+function assertNodeType(node, type) {
+  if (!node || node.type !== type) {
+    throw new Error(`Expected node of type ${type}, but got ` + (node ? `node of type ${node.type}` : String(node)));
+  }
+
+  return node;
+}
+/**
+ * Returns the node more strictly typed iff it is of the given type. Otherwise,
+ * returns null.
+ */
+
+function assertSymbolNodeType(node) {
+  const typedNode = checkSymbolNodeType(node);
+
+  if (!typedNode) {
+    throw new Error(`Expected node of symbol group type, but got ` + (node ? `node of type ${node.type}` : String(node)));
+  }
+
+  return typedNode;
+}
+/**
+ * Returns the node more strictly typed iff it is of the given type. Otherwise,
+ * returns null.
+ */
+
+function checkSymbolNodeType(node) {
+  if (node && (node.type === "atom" || NON_ATOMS.hasOwnProperty(node.type))) {
+    // $FlowFixMe
+    return node;
+  }
+
+  return null;
+}
+
 // NOTE: Unlike most `htmlBuilder`s, this one handles not only "accent", but
 const htmlBuilder = (grp, options) => {
   // Accents are handled in the TeXbook pg. 443, rule 12.
   let base;
   let group;
-  const supSub = checkNodeType(grp, "supsub");
   let supSubGroup;
 
-  if (supSub) {
+  if (grp && grp.type === "supsub") {
     // If our base is a character box, and we have superscripts and
     // subscripts, the supsub will defer to us. In particular, we want
     // to attach the superscripts and subscripts to the inner body (so
@@ -7554,16 +7421,16 @@ const htmlBuilder = (grp, options) => {
     // sticking the base of the accent into the base of the supsub, and
     // rendering that, while keeping track of where the accent is.
     // The real accent group is the base of the supsub group
-    group = assertNodeType(supSub.base, "accent"); // The character box is the base of the accent group
+    group = assertNodeType(grp.base, "accent"); // The character box is the base of the accent group
 
     base = group.base; // Stick the character box into the base of the supsub group
 
-    supSub.base = base; // Rerender the supsub group with its new base, and store that
+    grp.base = base; // Rerender the supsub group with its new base, and store that
     // result.
 
-    supSubGroup = assertSpan(buildGroup(supSub, options)); // reset original base
+    supSubGroup = assertSpan(buildGroup(grp, options)); // reset original base
 
-    supSub.base = group;
+    grp.base = group;
   } else {
     group = assertNodeType(grp, "accent");
     base = group.base;
@@ -7779,8 +7646,8 @@ defineFunction({
     const kern = group.label === "\\utilde" ? 0.12 : 0; // Generate the vlist, with the appropriate kerns
 
     const vlist = buildCommon.makeVList({
-      positionType: "bottom",
-      positionData: accentBody.height + kern,
+      positionType: "top",
+      positionData: innerGroup.height,
       children: [{
         type: "elem",
         elem: accentBody,
@@ -8075,47 +7942,249 @@ defineFunction({
       }
     }
 
-    return {
-      type: "cr",
-      mode: parser.mode,
-      newLine,
-      newRow,
-      size: size && assertNodeType(size, "size").value
-    };
+    return {
+      type: "cr",
+      mode: parser.mode,
+      newLine,
+      newRow,
+      size: size && assertNodeType(size, "size").value
+    };
+  },
+
+  // The following builders are called only at the top level,
+  // not within tabular/array environments.
+  htmlBuilder(group, options) {
+    if (group.newRow) {
+      throw new ParseError("\\cr valid only within a tabular/array environment");
+    }
+
+    const span = buildCommon.makeSpan(["mspace"], [], options);
+
+    if (group.newLine) {
+      span.classes.push("newline");
+
+      if (group.size) {
+        span.style.marginTop = calculateSize(group.size, options) + "em";
+      }
+    }
+
+    return span;
+  },
+
+  mathmlBuilder(group, options) {
+    const node = new mathMLTree.MathNode("mspace");
+
+    if (group.newLine) {
+      node.setAttribute("linebreak", "newline");
+
+      if (group.size) {
+        node.setAttribute("height", calculateSize(group.size, options) + "em");
+      }
+    }
+
+    return node;
+  }
+
+});
+
+const globalMap = {
+  "\\global": "\\global",
+  "\\long": "\\\\globallong",
+  "\\\\globallong": "\\\\globallong",
+  "\\def": "\\gdef",
+  "\\gdef": "\\gdef",
+  "\\edef": "\\xdef",
+  "\\xdef": "\\xdef",
+  "\\let": "\\\\globallet",
+  "\\futurelet": "\\\\globalfuture"
+};
+
+const checkControlSequence = tok => {
+  const name = tok.text;
+
+  if (/^(?:[\\{}$&#^_]|EOF)$/.test(name)) {
+    throw new ParseError("Expected a control sequence", tok);
+  }
+
+  return name;
+};
+
+const getRHS = parser => {
+  let tok = parser.gullet.popToken();
+
+  if (tok.text === "=") {
+    // consume optional equals
+    tok = parser.gullet.popToken();
+
+    if (tok.text === " ") {
+      // consume one optional space
+      tok = parser.gullet.popToken();
+    }
+  }
+
+  return tok;
+};
+
+const letCommand = (parser, name, tok, global) => {
+  let macro = parser.gullet.macros.get(tok.text);
+
+  if (macro == null) {
+    // don't expand it later even if a macro with the same name is defined
+    // e.g., \let\foo=\frac \def\frac{\relax} \frac12
+    tok.noexpand = true;
+    macro = {
+      tokens: [tok],
+      numArgs: 0,
+      // reproduce the same behavior in expansion
+      unexpandable: !parser.gullet.isExpandable(tok.text)
+    };
+  }
+
+  parser.gullet.macros.set(name, macro, global);
+}; // <assignment> -> <non-macro assignment>|<macro assignment>
+// <non-macro assignment> -> <simple assignment>|\global<non-macro assignment>
+// <macro assignment> -> <definition>|<prefix><macro assignment>
+// <prefix> -> \global|\long|\outer
+
+
+defineFunction({
+  type: "internal",
+  names: ["\\global", "\\long", "\\\\globallong"],
+  props: {
+    numArgs: 0,
+    allowedInText: true
+  },
+
+  handler(_ref) {
+    let parser = _ref.parser,
+        funcName = _ref.funcName;
+    parser.consumeSpaces();
+    const token = parser.fetch();
+
+    if (globalMap[token.text]) {
+      // KaTeX doesn't have \par, so ignore \long
+      if (funcName === "\\global" || funcName === "\\\\globallong") {
+        token.text = globalMap[token.text];
+      }
+
+      return assertNodeType(parser.parseFunction(), "internal");
+    }
+
+    throw new ParseError(`Invalid token after macro prefix`, token);
+  }
+
+}); // Basic support for macro definitions: \def, \gdef, \edef, \xdef
+// <definition> -> <def><control sequence><definition text>
+// <def> -> \def|\gdef|\edef|\xdef
+// <definition text> -> <parameter text><left brace><balanced text><right brace>
+
+defineFunction({
+  type: "internal",
+  names: ["\\def", "\\gdef", "\\edef", "\\xdef"],
+  props: {
+    numArgs: 0,
+    allowedInText: true
   },
 
-  // The following builders are called only at the top level,
-  // not within tabular/array environments.
-  htmlBuilder(group, options) {
-    if (group.newRow) {
-      throw new ParseError("\\cr valid only within a tabular/array environment");
+  handler(_ref2) {
+    let parser = _ref2.parser,
+        funcName = _ref2.funcName;
+    let arg = parser.gullet.consumeArgs(1)[0];
+
+    if (arg.length !== 1) {
+      throw new ParseError("\\gdef's first argument must be a macro name");
     }
 
-    const span = buildCommon.makeSpan(["mspace"], [], options);
+    const name = arg[0].text; // Count argument specifiers, and check they are in the order #1 #2 ...
 
-    if (group.newLine) {
-      span.classes.push("newline");
+    let numArgs = 0;
+    arg = parser.gullet.consumeArgs(1)[0];
 
-      if (group.size) {
-        span.style.marginTop = calculateSize(group.size, options) + "em";
+    while (arg.length === 1 && arg[0].text === "#") {
+      arg = parser.gullet.consumeArgs(1)[0];
+
+      if (arg.length !== 1) {
+        throw new ParseError(`Invalid argument number length "${arg.length}"`);
+      }
+
+      if (!/^[1-9]$/.test(arg[0].text)) {
+        throw new ParseError(`Invalid argument number "${arg[0].text}"`);
+      }
+
+      numArgs++;
+
+      if (parseInt(arg[0].text) !== numArgs) {
+        throw new ParseError(`Argument number "${arg[0].text}" out of order`);
       }
+
+      arg = parser.gullet.consumeArgs(1)[0];
     }
 
-    return span;
+    if (funcName === "\\edef" || funcName === "\\xdef") {
+      arg = parser.gullet.expandTokens(arg);
+      arg.reverse(); // to fit in with stack order
+    } // Final arg is the expansion of the macro
+
+
+    parser.gullet.macros.set(name, {
+      tokens: arg,
+      numArgs
+    }, funcName === globalMap[funcName]);
+    return {
+      type: "internal",
+      mode: parser.mode
+    };
+  }
+
+}); // <simple assignment> -> <let assignment>
+// <let assignment> -> \futurelet<control sequence><token><token>
+//     | \let<control sequence><equals><one optional space><token>
+// <equals> -> <optional spaces>|<optional spaces>=
+
+defineFunction({
+  type: "internal",
+  names: ["\\let", "\\\\globallet"],
+  props: {
+    numArgs: 0,
+    allowedInText: true
   },
 
-  mathmlBuilder(group, options) {
-    const node = new mathMLTree.MathNode("mspace");
+  handler(_ref3) {
+    let parser = _ref3.parser,
+        funcName = _ref3.funcName;
+    const name = checkControlSequence(parser.gullet.popToken());
+    parser.gullet.consumeSpaces();
+    const tok = getRHS(parser);
+    letCommand(parser, name, tok, funcName === "\\\\globallet");
+    return {
+      type: "internal",
+      mode: parser.mode
+    };
+  }
 
-    if (group.newLine) {
-      node.setAttribute("linebreak", "newline");
+}); // ref: https://www.tug.org/TUGboat/tb09-3/tb22bechtolsheim.pdf
 
-      if (group.size) {
-        node.setAttribute("height", calculateSize(group.size, options) + "em");
-      }
-    }
+defineFunction({
+  type: "internal",
+  names: ["\\futurelet", "\\\\globalfuture"],
+  props: {
+    numArgs: 0,
+    allowedInText: true
+  },
 
-    return node;
+  handler(_ref4) {
+    let parser = _ref4.parser,
+        funcName = _ref4.funcName;
+    const name = checkControlSequence(parser.gullet.popToken());
+    const middle = parser.gullet.popToken();
+    const tok = parser.gullet.popToken();
+    letCommand(parser, name, tok, funcName === "\\\\globalfuture");
+    parser.gullet.pushToken(tok);
+    parser.gullet.pushToken(middle);
+    return {
+      type: "internal",
+      mode: parser.mode
+    };
   }
 
 });
@@ -8439,12 +8508,33 @@ const makeStackedDelim = function makeStackedDelim(delim, heightTotal, center, o
   // at a position that juts 0.005 above the bottom of the top element.
 
 
-  inners.push({
-    type: "kern",
-    size: shiftOfExtraElement
-  });
-  inners.push(makeInner(repeat, font, mode));
-  inners.push(lap); // Add the top symbol
+  if ((repeat === "\u239c" || repeat === "\u239f") && repeatCount === 0) {
+    // Parentheses need a short repeat element in order to avoid an overrun.
+    // We'll make a 0.3em tall element from a SVG.
+    const overlap = buildCommon.svgData.leftParenInner[2] / 2;
+    inners.push({
+      type: "kern",
+      size: -overlap
+    });
+    const pathName = repeat === "\u239c" ? "leftParenInner" : "rightParenInner";
+    const innerSpan = buildCommon.staticSvg(pathName, options);
+    inners.push({
+      type: "elem",
+      elem: innerSpan
+    });
+    inners.push({
+      type: "kern",
+      size: -overlap
+    });
+  } else {
+    inners.push({
+      type: "kern",
+      size: shiftOfExtraElement
+    });
+    inners.push(makeInner(repeat, font, mode));
+    inners.push(lap);
+  } // Add the top symbol
+
 
   inners.push(makeInner(top, font, mode)); // Finally, build the vlist
 
@@ -8859,8 +8949,10 @@ function checkDelimiter(delim, context) {
 
   if (symDelim && utils.contains(delimiters, symDelim.text)) {
     return symDelim;
+  } else if (symDelim) {
+    throw new ParseError(`Invalid delimiter '${symDelim.text}' after '${context.funcName}'`, delim);
   } else {
-    throw new ParseError("Invalid delimiter: '" + (symDelim ? symDelim.text : JSON.stringify(delim)) + "' after '" + context.funcName + "'", delim);
+    throw new ParseError(`Invalid delimiter type '${delim.type}'`, delim);
   }
 }
 
@@ -9832,7 +9924,7 @@ const mathmlBuilder$3 = function mathmlBuilder(group, options) {
   let menclose = "";
   let align = "";
 
-  if (group.cols) {
+  if (group.cols && group.cols.length > 0) {
     // Find column alignment, column spacing, and  vertical lines.
     const cols = group.cols;
     let columnLines = "";
@@ -9946,13 +10038,12 @@ const alignedHandler = function alignedHandler(context, args) {
     mode: context.mode,
     body: []
   };
-  const ordgroup = checkNodeType(args[0], "ordgroup");
 
-  if (ordgroup) {
+  if (args[0] && args[0].type === "ordgroup") {
     let arg0 = "";
 
-    for (let i = 0; i < ordgroup.body.length; i++) {
-      const textord = assertNodeType(ordgroup.body[i], "textord");
+    for (let i = 0; i < args[0].body.length; i++) {
+      const textord = assertNodeType(args[0].body[i], "textord");
       arg0 += textord.text;
     }
 
@@ -10151,7 +10242,7 @@ defineEnvironment({
     };
     res = parseArray(context.parser, res, "script");
 
-    if (res.body[0].length > 1) {
+    if (res.body.length > 0 && res.body[0].length > 1) {
       throw new ParseError("{subarray} can contain only one column");
     }
 
@@ -10165,10 +10256,11 @@ defineEnvironment({
 // \left\{\begin{array}{@{}l@{\quad}l@{}} … \end{array}\right.
 // {dcases} is a {cases} environment where cells are set in \displaystyle,
 // as defined in mathtools.sty.
+// {rcases} is another mathtools environment. It's brace is on the right side.
 
 defineEnvironment({
   type: "array",
-  names: ["cases", "dcases"],
+  names: ["cases", "dcases", "rcases", "drcases"],
   props: {
     numArgs: 0
   },
@@ -10199,8 +10291,8 @@ defineEnvironment({
       type: "leftright",
       mode: context.mode,
       body: [res],
-      left: "\\{",
-      right: ".",
+      left: context.envName.indexOf("r") > -1 ? "." : "\\{",
+      right: context.envName.indexOf("r") > -1 ? "\\}" : ".",
       rightColor: undefined
     };
   },
@@ -10587,7 +10679,7 @@ defineFunction({
 
 defineFunction({
   type: "font",
-  names: ["\\rm", "\\sf", "\\tt", "\\bf", "\\it"],
+  names: ["\\rm", "\\sf", "\\tt", "\\bf", "\\it", "\\cal"],
   props: {
     numArgs: 0,
     allowedInText: true
@@ -10992,20 +11084,8 @@ defineFunction({
     const numer = args[4];
     const denom = args[5]; // Look into the parse nodes to get the desired delimiters.
 
-    let leftNode = checkNodeType(args[0], "atom");
-
-    if (leftNode) {
-      leftNode = assertAtomFamily(args[0], "open");
-    }
-
-    const leftDelim = leftNode ? delimFromValue(leftNode.text) : null;
-    let rightNode = checkNodeType(args[1], "atom");
-
-    if (rightNode) {
-      rightNode = assertAtomFamily(args[1], "close");
-    }
-
-    const rightDelim = rightNode ? delimFromValue(rightNode.text) : null;
+    const leftDelim = args[0].type === "atom" && args[0].family === "open" ? delimFromValue(args[0].text) : null;
+    const rightDelim = args[1].type === "atom" && args[1].family === "close" ? delimFromValue(args[1].text) : null;
     const barNode = assertNodeType(args[2], "size");
     let hasBarLine;
     let barSize = null;
@@ -11022,15 +11102,15 @@ defineFunction({
 
 
     let size = "auto";
-    let styl = checkNodeType(args[3], "ordgroup");
+    let styl = args[3];
 
-    if (styl) {
+    if (styl.type === "ordgroup") {
       if (styl.body.length > 0) {
         const textOrd = assertNodeType(styl.body[0], "textord");
         size = stylArray[Number(textOrd.text)];
       }
     } else {
-      styl = assertNodeType(args[3], "textord");
+      styl = assertNodeType(styl, "textord");
       size = stylArray[Number(styl.text)];
     }
 
@@ -11112,14 +11192,13 @@ const htmlBuilder$7 = (grp, options) => {
 
   let supSubGroup;
   let group;
-  const supSub = checkNodeType(grp, "supsub");
 
-  if (supSub) {
+  if (grp.type === "supsub") {
     // Ref: LaTeX source2e: }}}}\limits}
     // i.e. LaTeX treats the brace similar to an op and passes it
     // with \limits, so we need to assign supsub style.
-    supSubGroup = supSub.sup ? buildGroup(supSub.sup, options.havingStyle(style.sup()), options) : buildGroup(supSub.sub, options.havingStyle(style.sub()), options);
-    group = assertNodeType(supSub.base, "horizBrace");
+    supSubGroup = grp.sup ? buildGroup(grp.sup, options.havingStyle(style.sup()), options) : buildGroup(grp.sub, options.havingStyle(style.sub()), options);
+    group = assertNodeType(grp.base, "horizBrace");
   } else {
     group = assertNodeType(grp, "horizBrace");
   } // Build the base group
@@ -11333,6 +11412,112 @@ defineFunction({
   }
 });
 
+defineFunction({
+  type: "html",
+  names: ["\\htmlClass", "\\htmlId", "\\htmlStyle", "\\htmlData"],
+  props: {
+    numArgs: 2,
+    argTypes: ["raw", "original"],
+    allowedInText: true
+  },
+  handler: (_ref, args) => {
+    let parser = _ref.parser,
+        funcName = _ref.funcName,
+        token = _ref.token;
+    const value = assertNodeType(args[0], "raw").string;
+    const body = args[1];
+
+    if (parser.settings.strict) {
+      parser.settings.reportNonstrict("htmlExtension", "HTML extension is disabled on strict mode");
+    }
+
+    let trustContext;
+    const attributes = {};
+
+    switch (funcName) {
+      case "\\htmlClass":
+        attributes.class = value;
+        trustContext = {
+          command: "\\htmlClass",
+          class: value
+        };
+        break;
+
+      case "\\htmlId":
+        attributes.id = value;
+        trustContext = {
+          command: "\\htmlId",
+          id: value
+        };
+        break;
+
+      case "\\htmlStyle":
+        attributes.style = value;
+        trustContext = {
+          command: "\\htmlStyle",
+          style: value
+        };
+        break;
+
+      case "\\htmlData":
+        {
+          const data = value.split(",");
+
+          for (let i = 0; i < data.length; i++) {
+            const keyVal = data[i].split("=");
+
+            if (keyVal.length !== 2) {
+              throw new ParseError("Error parsing key-value for \\htmlData");
+            }
+
+            attributes["data-" + keyVal[0].trim()] = keyVal[1].trim();
+          }
+
+          trustContext = {
+            command: "\\htmlData",
+            attributes
+          };
+          break;
+        }
+
+      default:
+        throw new Error("Unrecognized html command");
+    }
+
+    if (!parser.settings.isTrusted(trustContext)) {
+      return parser.formatUnsupportedCmd(funcName);
+    }
+
+    return {
+      type: "html",
+      mode: parser.mode,
+      attributes,
+      body: ordargument(body)
+    };
+  },
+  htmlBuilder: (group, options) => {
+    const elements = buildExpression(group.body, options, false);
+    const classes = ["enclosing"];
+
+    if (group.attributes.class) {
+      classes.push(...group.attributes.class.trim().split(/\s+/));
+    }
+
+    const span = buildCommon.makeSpan(classes, elements, options);
+
+    for (const attr in group.attributes) {
+      if (attr !== "class" && group.attributes.hasOwnProperty(attr)) {
+        span.setAttribute(attr, group.attributes[attr]);
+      }
+    }
+
+    return span;
+  },
+  mathmlBuilder: (group, options) => {
+    return buildExpressionRow(group.body, options);
+  }
+});
+
 defineFunction({
   type: "htmlmathml",
   names: ["\\html@mathml"],
@@ -11622,21 +11807,16 @@ defineFunction({
     // two items involved in the lap.
     // Next, use a strut to set the height of the HTML bounding box.
     // Otherwise, a tall argument may be misplaced.
+    // This code resolved issue #1153
 
     const strut = buildCommon.makeSpan(["strut"]);
     strut.style.height = node.height + node.depth + "em";
     strut.style.verticalAlign = -node.depth + "em";
     node.children.unshift(strut); // Next, prevent vertical misplacement when next to something tall.
+    // This code resolves issue #1234
 
-    node = buildCommon.makeVList({
-      positionType: "firstBaseline",
-      children: [{
-        type: "elem",
-        elem: node
-      }]
-    }, options); // Get the horizontal spacing correct relative to adjacent items.
-
-    return buildCommon.makeSpan(["mord"], [node], options);
+    node = buildCommon.makeSpan(["thinbox"], [node], options);
+    return buildCommon.makeSpan(["mord", "vbox"], [node], options);
   },
   mathmlBuilder: (group, options) => {
     // mathllap, mathrlap, mathclap
@@ -11745,8 +11925,6 @@ defineFunction({
 
 // For an operator with limits, assemble the base, sup, and sub into a span.
 const assembleSupSub = (base, supGroup, subGroup, options, style, slant, baseShift) => {
-  // IE 8 clips \int if it is in a display: inline-block. We wrap it
-  // in a new span so it is an inline, and works.
   base = buildCommon.makeSpan([], [base]);
   let sub;
   let sup; // We manually have to handle the superscripts and subscripts. This,
@@ -11867,15 +12045,14 @@ const htmlBuilder$8 = (grp, options) => {
   let subGroup;
   let hasLimits = false;
   let group;
-  const supSub = checkNodeType(grp, "supsub");
 
-  if (supSub) {
+  if (grp.type === "supsub") {
     // If we have limits, supsub will pass us its group to handle. Pull
     // out the superscript and subscript and set the group to the op in
     // its base.
-    supGroup = supSub.sup;
-    subGroup = supSub.sub;
-    group = assertNodeType(supSub.base, "op");
+    supGroup = grp.sup;
+    subGroup = grp.sub;
+    group = assertNodeType(grp.base, "op");
     hasLimits = true;
   } else {
     group = assertNodeType(grp, "op");
@@ -12175,15 +12352,14 @@ const htmlBuilder$9 = (grp, options) => {
   let subGroup;
   let hasLimits = false;
   let group;
-  const supSub = checkNodeType(grp, "supsub");
 
-  if (supSub) {
+  if (grp.type === "supsub") {
     // If we have limits, supsub will pass us its group to handle. Pull
     // out the superscript and subscript and set the group to the op in
     // its base.
-    supGroup = supSub.sup;
-    subGroup = supSub.sub;
-    group = assertNodeType(supSub.base, "operatorname");
+    supGroup = grp.sup;
+    subGroup = grp.sub;
+    group = assertNodeType(grp.base, "operatorname");
     hasLimits = true;
   } else {
     group = assertNodeType(grp, "operatorname");
@@ -13130,14 +13306,13 @@ defineFunctionBuilders({
     let isBrace = false;
     let isOver;
     let isSup;
-    const horizBrace = checkNodeType(group.base, "horizBrace");
 
-    if (horizBrace) {
+    if (group.base && group.base.type === "horizBrace") {
       isSup = !!group.sup;
 
-      if (isSup === horizBrace.isOver) {
+      if (isSup === group.base.isOver) {
         isBrace = true;
-        isOver = horizBrace.isOver;
+        isOver = group.base.isOver;
       }
     }
 
@@ -13801,7 +13976,37 @@ function defineMacro(name, body) {
   builtinMacros[name] = body;
 } //////////////////////////////////////////////////////////////////////
 // macro tools
-// LaTeX's \@firstoftwo{#1}{#2} expands to #1, skipping #2
+
+defineMacro("\\noexpand", function (context) {
+  // The expansion is the token itself; but that token is interpreted
+  // as if its meaning were ‘\relax’ if it is a control sequence that
+  // would ordinarily be expanded by TeX’s expansion rules.
+  const t = context.popToken();
+
+  if (context.isExpandable(t.text)) {
+    t.noexpand = true;
+    t.treatAsRelax = true;
+  }
+
+  return {
+    tokens: [t],
+    numArgs: 0
+  };
+});
+defineMacro("\\expandafter", function (context) {
+  // TeX first reads the token that comes immediately after \expandafter,
+  // without expanding it; let’s call this token t. Then TeX reads the
+  // token that comes after t (and possibly more tokens, if that token
+  // has an argument), replacing it by its expansion. Finally TeX puts
+  // t back in front of that expansion.
+  const t = context.popToken();
+  context.expandOnce(true); // expand only an expandable token
+
+  return {
+    tokens: [t],
+    numArgs: 0
+  };
+}); // LaTeX's \@firstoftwo{#1}{#2} expands to #1, skipping #2
 // TeX source: \long\def\@firstoftwo#1#2{#1}
 
 defineMacro("\\@firstoftwo", function (context) {
@@ -13820,12 +14025,14 @@ defineMacro("\\@secondoftwo", function (context) {
     numArgs: 0
   };
 }); // LaTeX's \@ifnextchar{#1}{#2}{#3} looks ahead to the next (unexpanded)
-// symbol.  If it matches #1, then the macro expands to #2; otherwise, #3.
-// Note, however, that it does not consume the next symbol in either case.
+// symbol that isn't a space, consuming any spaces but not consuming the
+// first nonspace character.  If that nonspace character matches #1, then
+// the macro expands to #2; otherwise, it expands to #3.
 
 defineMacro("\\@ifnextchar", function (context) {
   const args = context.consumeArgs(3); // symbol, if, else
 
+  context.consumeSpaces();
   const nextToken = context.future();
 
   if (args[0].length === 1 && args[0][0].text === nextToken.text) {
@@ -13938,70 +14145,6 @@ defineMacro("\\char", function (context) {
   }
 
   return `\\@char{${number}}`;
-}); // Basic support for macro definitions:
-//     \def\macro{expansion}
-//     \def\macro#1{expansion}
-//     \def\macro#1#2{expansion}
-//     \def\macro#1#2#3#4#5#6#7#8#9{expansion}
-// Also the \gdef and \global\def equivalents
-
-const def = (context, global) => {
-  let arg = context.consumeArgs(1)[0];
-
-  if (arg.length !== 1) {
-    throw new ParseError("\\gdef's first argument must be a macro name");
-  }
-
-  const name = arg[0].text; // Count argument specifiers, and check they are in the order #1 #2 ...
-
-  let numArgs = 0;
-  arg = context.consumeArgs(1)[0];
-
-  while (arg.length === 1 && arg[0].text === "#") {
-    arg = context.consumeArgs(1)[0];
-
-    if (arg.length !== 1) {
-      throw new ParseError(`Invalid argument number length "${arg.length}"`);
-    }
-
-    if (!/^[1-9]$/.test(arg[0].text)) {
-      throw new ParseError(`Invalid argument number "${arg[0].text}"`);
-    }
-
-    numArgs++;
-
-    if (parseInt(arg[0].text) !== numArgs) {
-      throw new ParseError(`Argument number "${arg[0].text}" out of order`);
-    }
-
-    arg = context.consumeArgs(1)[0];
-  } // Final arg is the expansion of the macro
-
-
-  context.macros.set(name, {
-    tokens: arg,
-    numArgs
-  }, global);
-  return '';
-};
-
-defineMacro("\\gdef", context => def(context, true));
-defineMacro("\\def", context => def(context, false));
-defineMacro("\\global", context => {
-  const next = context.consumeArgs(1)[0];
-
-  if (next.length !== 1) {
-    throw new ParseError("Invalid command after \\global");
-  }
-
-  const command = next[0].text; // TODO: Should expand command
-
-  if (command === "\\def") {
-    // \global\def is equivalent to \gdef
-    return def(context, true);
-  } else {
-    throw new ParseError(`Invalid command '${command}' after \\global`);
-  }
 }); // \newcommand{\macro}[args]{definition}
 // \renewcommand{\macro}[args]{definition}
 // TODO: Optional arguments: \newcommand{\macro}[args][default]{definition}
@@ -14055,7 +14198,27 @@ const newcommand = (context, existsOK, nonexistsOK) => {
 
 defineMacro("\\newcommand", context => newcommand(context, false, true));
 defineMacro("\\renewcommand", context => newcommand(context, true, false));
-defineMacro("\\providecommand", context => newcommand(context, true, true)); //////////////////////////////////////////////////////////////////////
+defineMacro("\\providecommand", context => newcommand(context, true, true)); // terminal (console) tools
+
+defineMacro("\\message", context => {
+  const arg = context.consumeArgs(1)[0]; // eslint-disable-next-line no-console
+
+  console.log(arg.reverse().map(token => token.text).join(""));
+  return '';
+});
+defineMacro("\\errmessage", context => {
+  const arg = context.consumeArgs(1)[0]; // eslint-disable-next-line no-console
+
+  console.error(arg.reverse().map(token => token.text).join(""));
+  return '';
+});
+defineMacro("\\show", context => {
+  const tok = context.popToken();
+  const name = tok.text; // eslint-disable-next-line no-console
+
+  console.log(tok, context.macros.get(name), functions[name], symbols.math[name], symbols.text[name]);
+  return '';
+}); //////////////////////////////////////////////////////////////////////
 // Grouping
 // \let\bgroup={ \let\egroup=}
 
@@ -14137,7 +14300,13 @@ defineMacro("\u231E", "\\llcorner");
 defineMacro("\u231F", "\\lrcorner");
 defineMacro("\u00A9", "\\copyright");
 defineMacro("\u00AE", "\\textregistered");
-defineMacro("\uFE0F", "\\textregistered"); //////////////////////////////////////////////////////////////////////
+defineMacro("\uFE0F", "\\textregistered"); // The KaTeX fonts have corners at codepoints that don't match Unicode.
+// For MathML purposes, use the Unicode code point.
+
+defineMacro("\\ulcorner", "\\html@mathml{\\@ulcorner}{\\mathop{\\char\"231c}}");
+defineMacro("\\urcorner", "\\html@mathml{\\@urcorner}{\\mathop{\\char\"231d}}");
+defineMacro("\\llcorner", "\\html@mathml{\\@llcorner}{\\mathop{\\char\"231e}}");
+defineMacro("\\lrcorner", "\\html@mathml{\\@lrcorner}{\\mathop{\\char\"231f}}"); //////////////////////////////////////////////////////////////////////
 // LaTeX_2ε
 // \vdots{\vbox{\baselineskip4\p@  \lineskiplimit\z@
 // \kern6\p@\hbox{.}\hbox{.}\hbox{.}}}
@@ -14506,7 +14675,9 @@ defineMacro("\\nsupseteqq", "\\html@mathml{\\@nsupseteqq}{\u2289}");
 defineMacro("\\varsubsetneq", "\\html@mathml{\\@varsubsetneq}{⊊}");
 defineMacro("\\varsubsetneqq", "\\html@mathml{\\@varsubsetneqq}{⫋}");
 defineMacro("\\varsupsetneq", "\\html@mathml{\\@varsupsetneq}{⊋}");
-defineMacro("\\varsupsetneqq", "\\html@mathml{\\@varsupsetneqq}{⫌}"); //////////////////////////////////////////////////////////////////////
+defineMacro("\\varsupsetneqq", "\\html@mathml{\\@varsupsetneqq}{⫌}");
+defineMacro("\\imath", "\\html@mathml{\\@imath}{\u0131}");
+defineMacro("\\jmath", "\\html@mathml{\\@jmath}{\u0237}"); //////////////////////////////////////////////////////////////////////
 // stmaryrd and semantic
 // The stmaryrd and semantic packages render the next four items by calling a
 // glyph. Those glyphs do not exist in the KaTeX fonts. Hence the macros.
@@ -14524,7 +14695,11 @@ defineMacro("\u2983", "\\lBrace"); // blackboard bold {
 defineMacro("\u2984", "\\rBrace"); // blackboard bold }
 // TODO: Create variable sized versions of the last two items. I believe that
 // will require new font glyphs.
-//////////////////////////////////////////////////////////////////////
+// The stmaryrd function `\minuso` provides a "Plimsoll" symbol that
+// superimposes the characters \circ and \mathminus. Used in chemistry.
+
+defineMacro("\\minuso", "\\mathbin{\\html@mathml{" + "{\\mathrlap{\\mathchoice{\\kern{0.145em}}{\\kern{0.145em}}" + "{\\kern{0.1015em}}{\\kern{0.0725em}}\\circ}{-}}}" + "{\\char`⦵}}");
+defineMacro("⦵", "\\minuso"); //////////////////////////////////////////////////////////////////////
 // texvc.sty
 // The texvc package contains macros available in mediawiki pages.
 // We omit the functions deprecated at
@@ -14600,7 +14775,15 @@ defineMacro("\\Zeta", "\\mathrm{Z}"); //////////////////////////////////////////
 
 defineMacro("\\argmin", "\\DOTSB\\operatorname*{arg\\,min}");
 defineMacro("\\argmax", "\\DOTSB\\operatorname*{arg\\,max}");
-defineMacro("\\plim", "\\DOTSB\\mathop{\\operatorname{plim}}\\limits"); // Custom Khan Academy colors, should be moved to an optional package
+defineMacro("\\plim", "\\DOTSB\\mathop{\\operatorname{plim}}\\limits"); //////////////////////////////////////////////////////////////////////
+// braket.sty
+// http://ctan.math.washington.edu/tex-archive/macros/latex/contrib/braket/braket.pdf
+
+defineMacro("\\bra", "\\mathinner{\\langle{#1}|}");
+defineMacro("\\ket", "\\mathinner{|{#1}\\rangle}");
+defineMacro("\\braket", "\\mathinner{\\langle{#1}\\rangle}");
+defineMacro("\\Bra", "\\left\\langle#1\\right|");
+defineMacro("\\Ket", "\\left|#1\\right\\rangle"); // Custom Khan Academy colors, should be moved to an optional package
 
 defineMacro("\\blue", "\\textcolor{##6495ed}{#1}");
 defineMacro("\\orange", "\\textcolor{##ffa500}{#1}");
@@ -14846,18 +15029,22 @@ class MacroExpander {
    * At the moment, macro expansion doesn't handle delimited macros,
    * i.e. things like those defined by \def\foo#1\end{…}.
    * See the TeX book page 202ff. for details on how those should behave.
+   *
+   * If expandableOnly, only expandable tokens are expanded and
+   * an undefined control sequence results in an error.
    */
 
 
-  expandOnce() {
+  expandOnce(expandableOnly) {
     const topToken = this.popToken();
     const name = topToken.text;
+    const expansion = !topToken.noexpand ? this._getExpansion(name) : null;
 
-    const expansion = this._getExpansion(name);
+    if (expansion == null || expandableOnly && expansion.unexpandable) {
+      if (expandableOnly && expansion == null && name[0] === "\\" && !this.isDefined(name)) {
+        throw new ParseError("Undefined control sequence: " + name);
+      }
 
-    if (expansion == null) {
-      // mainly checking for undefined here
-      // Fully expanded
       this.pushToken(topToken);
       return topToken;
     }
@@ -14926,7 +15113,9 @@ class MacroExpander {
       if (expanded instanceof Token) {
         // \relax stops the expansion, but shouldn't get returned (a
         // null return value couldn't get implemented as a function).
-        if (expanded.text === "\\relax") {
+        // the token after \noexpand is interpreted as if its meaning
+        // were ‘\relax’
+        if (expanded.text === "\\relax" || expanded.treatAsRelax) {
           this.stack.pop();
         } else {
           return this.stack.pop(); // === expanded
@@ -14945,18 +15134,29 @@ class MacroExpander {
 
 
   expandMacro(name) {
-    if (!this.macros.get(name)) {
-      return undefined;
-    }
+    return this.macros.has(name) ? this.expandTokens([new Token(name)]) : undefined;
+  }
+  /**
+   * Fully expand the given token stream and return the resulting list of tokens
+   */
+
 
+  expandTokens(tokens) {
     const output = [];
     const oldStackLength = this.stack.length;
-    this.pushToken(new Token(name));
+    this.pushTokens(tokens);
 
     while (this.stack.length > oldStackLength) {
-      const expanded = this.expandOnce(); // expandOnce returns Token if and only if it's fully expanded.
+      const expanded = this.expandOnce(true); // expand only expandable tokens
+      // expandOnce returns Token if and only if it's fully expanded.
 
       if (expanded instanceof Token) {
+        if (expanded.treatAsRelax) {
+          // the expansion of \noexpand is the token itself
+          expanded.noexpand = false;
+          expanded.treatAsRelax = false;
+        }
+
         output.push(this.stack.pop());
       }
     }
@@ -15036,699 +15236,389 @@ class MacroExpander {
   isDefined(name) {
     return this.macros.has(name) || functions.hasOwnProperty(name) || symbols.math.hasOwnProperty(name) || symbols.text.hasOwnProperty(name) || implicitCommands.hasOwnProperty(name);
   }
+  /**
+   * Determine whether a command is expandable.
+   */
+
+
+  isExpandable(name) {
+    const macro = this.macros.get(name);
+    return macro != null ? typeof macro === "string" || typeof macro === "function" || !macro.unexpandable // TODO(ylem): #2085
+    : functions.hasOwnProperty(name)
+    /* && !functions[name].primitive*/
+    ;
+  }
 
 }
 
-// Mapping of Unicode accent characters to their LaTeX equivalent in text and
-// math mode (when they exist).
-var unicodeAccents = {
-  '\u0301': {
-    text: "\\'",
-    math: '\\acute'
+/* eslint no-constant-condition:0 */
+
+const unicodeAccents = {
+  "́": {
+    "text": "\\'",
+    "math": "\\acute"
   },
-  '\u0300': {
-    text: '\\`',
-    math: '\\grave'
+  "̀": {
+    "text": "\\`",
+    "math": "\\grave"
   },
-  '\u0308': {
-    text: '\\"',
-    math: '\\ddot'
+  "̈": {
+    "text": "\\\"",
+    "math": "\\ddot"
   },
-  '\u0303': {
-    text: '\\~',
-    math: '\\tilde'
+  "̃": {
+    "text": "\\~",
+    "math": "\\tilde"
   },
-  '\u0304': {
-    text: '\\=',
-    math: '\\bar'
+  "̄": {
+    "text": "\\=",
+    "math": "\\bar"
   },
-  '\u0306': {
-    text: '\\u',
-    math: '\\breve'
+  "̆": {
+    "text": "\\u",
+    "math": "\\breve"
   },
-  '\u030c': {
-    text: '\\v',
-    math: '\\check'
+  "̌": {
+    "text": "\\v",
+    "math": "\\check"
   },
-  '\u0302': {
-    text: '\\^',
-    math: '\\hat'
+  "̂": {
+    "text": "\\^",
+    "math": "\\hat"
   },
-  '\u0307': {
-    text: '\\.',
-    math: '\\dot'
+  "̇": {
+    "text": "\\.",
+    "math": "\\dot"
   },
-  '\u030a': {
-    text: '\\r',
-    math: '\\mathring'
+  "̊": {
+    "text": "\\r",
+    "math": "\\mathring"
   },
-  '\u030b': {
-    text: '\\H'
+  "̋": {
+    "text": "\\H"
   }
 };
-
-// This file is GENERATED by unicodeMake.js. DO NOT MODIFY.
-var unicodeSymbols = {
-  "\u00e1": "\u0061\u0301",
-  // á = \'{a}
-  "\u00e0": "\u0061\u0300",
-  // à = \`{a}
-  "\u00e4": "\u0061\u0308",
-  // ä = \"{a}
-  "\u01df": "\u0061\u0308\u0304",
-  // ǟ = \"\={a}
-  "\u00e3": "\u0061\u0303",
-  // ã = \~{a}
-  "\u0101": "\u0061\u0304",
-  // ā = \={a}
-  "\u0103": "\u0061\u0306",
-  // ă = \u{a}
-  "\u1eaf": "\u0061\u0306\u0301",
-  // ắ = \u\'{a}
-  "\u1eb1": "\u0061\u0306\u0300",
-  // ằ = \u\`{a}
-  "\u1eb5": "\u0061\u0306\u0303",
-  // ẵ = \u\~{a}
-  "\u01ce": "\u0061\u030c",
-  // ǎ = \v{a}
-  "\u00e2": "\u0061\u0302",
-  // â = \^{a}
-  "\u1ea5": "\u0061\u0302\u0301",
-  // ấ = \^\'{a}
-  "\u1ea7": "\u0061\u0302\u0300",
-  // ầ = \^\`{a}
-  "\u1eab": "\u0061\u0302\u0303",
-  // ẫ = \^\~{a}
-  "\u0227": "\u0061\u0307",
-  // ȧ = \.{a}
-  "\u01e1": "\u0061\u0307\u0304",
-  // ǡ = \.\={a}
-  "\u00e5": "\u0061\u030a",
-  // å = \r{a}
-  "\u01fb": "\u0061\u030a\u0301",
-  // ǻ = \r\'{a}
-  "\u1e03": "\u0062\u0307",
-  // ḃ = \.{b}
-  "\u0107": "\u0063\u0301",
-  // ć = \'{c}
-  "\u010d": "\u0063\u030c",
-  // č = \v{c}
-  "\u0109": "\u0063\u0302",
-  // ĉ = \^{c}
-  "\u010b": "\u0063\u0307",
-  // ċ = \.{c}
-  "\u010f": "\u0064\u030c",
-  // ď = \v{d}
-  "\u1e0b": "\u0064\u0307",
-  // ḋ = \.{d}
-  "\u00e9": "\u0065\u0301",
-  // é = \'{e}
-  "\u00e8": "\u0065\u0300",
-  // è = \`{e}
-  "\u00eb": "\u0065\u0308",
-  // ë = \"{e}
-  "\u1ebd": "\u0065\u0303",
-  // ẽ = \~{e}
-  "\u0113": "\u0065\u0304",
-  // ē = \={e}
-  "\u1e17": "\u0065\u0304\u0301",
-  // ḗ = \=\'{e}
-  "\u1e15": "\u0065\u0304\u0300",
-  // ḕ = \=\`{e}
-  "\u0115": "\u0065\u0306",
-  // ĕ = \u{e}
-  "\u011b": "\u0065\u030c",
-  // ě = \v{e}
-  "\u00ea": "\u0065\u0302",
-  // ê = \^{e}
-  "\u1ebf": "\u0065\u0302\u0301",
-  // ế = \^\'{e}
-  "\u1ec1": "\u0065\u0302\u0300",
-  // ề = \^\`{e}
-  "\u1ec5": "\u0065\u0302\u0303",
-  // ễ = \^\~{e}
-  "\u0117": "\u0065\u0307",
-  // ė = \.{e}
-  "\u1e1f": "\u0066\u0307",
-  // ḟ = \.{f}
-  "\u01f5": "\u0067\u0301",
-  // ǵ = \'{g}
-  "\u1e21": "\u0067\u0304",
-  // ḡ = \={g}
-  "\u011f": "\u0067\u0306",
-  // ğ = \u{g}
-  "\u01e7": "\u0067\u030c",
-  // ǧ = \v{g}
-  "\u011d": "\u0067\u0302",
-  // ĝ = \^{g}
-  "\u0121": "\u0067\u0307",
-  // ġ = \.{g}
-  "\u1e27": "\u0068\u0308",
-  // ḧ = \"{h}
-  "\u021f": "\u0068\u030c",
-  // ȟ = \v{h}
-  "\u0125": "\u0068\u0302",
-  // ĥ = \^{h}
-  "\u1e23": "\u0068\u0307",
-  // ḣ = \.{h}
-  "\u00ed": "\u0069\u0301",
-  // í = \'{i}
-  "\u00ec": "\u0069\u0300",
-  // ì = \`{i}
-  "\u00ef": "\u0069\u0308",
-  // ï = \"{i}
-  "\u1e2f": "\u0069\u0308\u0301",
-  // ḯ = \"\'{i}
-  "\u0129": "\u0069\u0303",
-  // ĩ = \~{i}
-  "\u012b": "\u0069\u0304",
-  // ī = \={i}
-  "\u012d": "\u0069\u0306",
-  // ĭ = \u{i}
-  "\u01d0": "\u0069\u030c",
-  // ǐ = \v{i}
-  "\u00ee": "\u0069\u0302",
-  // î = \^{i}
-  "\u01f0": "\u006a\u030c",
-  // ǰ = \v{j}
-  "\u0135": "\u006a\u0302",
-  // ĵ = \^{j}
-  "\u1e31": "\u006b\u0301",
-  // ḱ = \'{k}
-  "\u01e9": "\u006b\u030c",
-  // ǩ = \v{k}
-  "\u013a": "\u006c\u0301",
-  // ĺ = \'{l}
-  "\u013e": "\u006c\u030c",
-  // ľ = \v{l}
-  "\u1e3f": "\u006d\u0301",
-  // ḿ = \'{m}
-  "\u1e41": "\u006d\u0307",
-  // ṁ = \.{m}
-  "\u0144": "\u006e\u0301",
-  // ń = \'{n}
-  "\u01f9": "\u006e\u0300",
-  // ǹ = \`{n}
-  "\u00f1": "\u006e\u0303",
-  // ñ = \~{n}
-  "\u0148": "\u006e\u030c",
-  // ň = \v{n}
-  "\u1e45": "\u006e\u0307",
-  // ṅ = \.{n}
-  "\u00f3": "\u006f\u0301",
-  // ó = \'{o}
-  "\u00f2": "\u006f\u0300",
-  // ò = \`{o}
-  "\u00f6": "\u006f\u0308",
-  // ö = \"{o}
-  "\u022b": "\u006f\u0308\u0304",
-  // ȫ = \"\={o}
-  "\u00f5": "\u006f\u0303",
-  // õ = \~{o}
-  "\u1e4d": "\u006f\u0303\u0301",
-  // ṍ = \~\'{o}
-  "\u1e4f": "\u006f\u0303\u0308",
-  // ṏ = \~\"{o}
-  "\u022d": "\u006f\u0303\u0304",
-  // ȭ = \~\={o}
-  "\u014d": "\u006f\u0304",
-  // ō = \={o}
-  "\u1e53": "\u006f\u0304\u0301",
-  // ṓ = \=\'{o}
-  "\u1e51": "\u006f\u0304\u0300",
-  // ṑ = \=\`{o}
-  "\u014f": "\u006f\u0306",
-  // ŏ = \u{o}
-  "\u01d2": "\u006f\u030c",
-  // ǒ = \v{o}
-  "\u00f4": "\u006f\u0302",
-  // ô = \^{o}
-  "\u1ed1": "\u006f\u0302\u0301",
-  // ố = \^\'{o}
-  "\u1ed3": "\u006f\u0302\u0300",
-  // ồ = \^\`{o}
-  "\u1ed7": "\u006f\u0302\u0303",
-  // ỗ = \^\~{o}
-  "\u022f": "\u006f\u0307",
-  // ȯ = \.{o}
-  "\u0231": "\u006f\u0307\u0304",
-  // ȱ = \.\={o}
-  "\u0151": "\u006f\u030b",
-  // ő = \H{o}
-  "\u1e55": "\u0070\u0301",
-  // ṕ = \'{p}
-  "\u1e57": "\u0070\u0307",
-  // ṗ = \.{p}
-  "\u0155": "\u0072\u0301",
-  // ŕ = \'{r}
-  "\u0159": "\u0072\u030c",
-  // ř = \v{r}
-  "\u1e59": "\u0072\u0307",
-  // ṙ = \.{r}
-  "\u015b": "\u0073\u0301",
-  // ś = \'{s}
-  "\u1e65": "\u0073\u0301\u0307",
-  // ṥ = \'\.{s}
-  "\u0161": "\u0073\u030c",
-  // š = \v{s}
-  "\u1e67": "\u0073\u030c\u0307",
-  // ṧ = \v\.{s}
-  "\u015d": "\u0073\u0302",
-  // ŝ = \^{s}
-  "\u1e61": "\u0073\u0307",
-  // ṡ = \.{s}
-  "\u1e97": "\u0074\u0308",
-  // ẗ = \"{t}
-  "\u0165": "\u0074\u030c",
-  // ť = \v{t}
-  "\u1e6b": "\u0074\u0307",
-  // ṫ = \.{t}
-  "\u00fa": "\u0075\u0301",
-  // ú = \'{u}
-  "\u00f9": "\u0075\u0300",
-  // ù = \`{u}
-  "\u00fc": "\u0075\u0308",
-  // ü = \"{u}
-  "\u01d8": "\u0075\u0308\u0301",
-  // ǘ = \"\'{u}
-  "\u01dc": "\u0075\u0308\u0300",
-  // ǜ = \"\`{u}
-  "\u01d6": "\u0075\u0308\u0304",
-  // ǖ = \"\={u}
-  "\u01da": "\u0075\u0308\u030c",
-  // ǚ = \"\v{u}
-  "\u0169": "\u0075\u0303",
-  // ũ = \~{u}
-  "\u1e79": "\u0075\u0303\u0301",
-  // ṹ = \~\'{u}
-  "\u016b": "\u0075\u0304",
-  // ū = \={u}
-  "\u1e7b": "\u0075\u0304\u0308",
-  // ṻ = \=\"{u}
-  "\u016d": "\u0075\u0306",
-  // ŭ = \u{u}
-  "\u01d4": "\u0075\u030c",
-  // ǔ = \v{u}
-  "\u00fb": "\u0075\u0302",
-  // û = \^{u}
-  "\u016f": "\u0075\u030a",
-  // ů = \r{u}
-  "\u0171": "\u0075\u030b",
-  // ű = \H{u}
-  "\u1e7d": "\u0076\u0303",
-  // ṽ = \~{v}
-  "\u1e83": "\u0077\u0301",
-  // ẃ = \'{w}
-  "\u1e81": "\u0077\u0300",
-  // ẁ = \`{w}
-  "\u1e85": "\u0077\u0308",
-  // ẅ = \"{w}
-  "\u0175": "\u0077\u0302",
-  // ŵ = \^{w}
-  "\u1e87": "\u0077\u0307",
-  // ẇ = \.{w}
-  "\u1e98": "\u0077\u030a",
-  // ẘ = \r{w}
-  "\u1e8d": "\u0078\u0308",
-  // ẍ = \"{x}
-  "\u1e8b": "\u0078\u0307",
-  // ẋ = \.{x}
-  "\u00fd": "\u0079\u0301",
-  // ý = \'{y}
-  "\u1ef3": "\u0079\u0300",
-  // ỳ = \`{y}
-  "\u00ff": "\u0079\u0308",
-  // ÿ = \"{y}
-  "\u1ef9": "\u0079\u0303",
-  // ỹ = \~{y}
-  "\u0233": "\u0079\u0304",
-  // ȳ = \={y}
-  "\u0177": "\u0079\u0302",
-  // ŷ = \^{y}
-  "\u1e8f": "\u0079\u0307",
-  // ẏ = \.{y}
-  "\u1e99": "\u0079\u030a",
-  // ẙ = \r{y}
-  "\u017a": "\u007a\u0301",
-  // ź = \'{z}
-  "\u017e": "\u007a\u030c",
-  // ž = \v{z}
-  "\u1e91": "\u007a\u0302",
-  // ẑ = \^{z}
-  "\u017c": "\u007a\u0307",
-  // ż = \.{z}
-  "\u00c1": "\u0041\u0301",
-  // Á = \'{A}
-  "\u00c0": "\u0041\u0300",
-  // À = \`{A}
-  "\u00c4": "\u0041\u0308",
-  // Ä = \"{A}
-  "\u01de": "\u0041\u0308\u0304",
-  // Ǟ = \"\={A}
-  "\u00c3": "\u0041\u0303",
-  // Ã = \~{A}
-  "\u0100": "\u0041\u0304",
-  // Ā = \={A}
-  "\u0102": "\u0041\u0306",
-  // Ă = \u{A}
-  "\u1eae": "\u0041\u0306\u0301",
-  // Ắ = \u\'{A}
-  "\u1eb0": "\u0041\u0306\u0300",
-  // Ằ = \u\`{A}
-  "\u1eb4": "\u0041\u0306\u0303",
-  // Ẵ = \u\~{A}
-  "\u01cd": "\u0041\u030c",
-  // Ǎ = \v{A}
-  "\u00c2": "\u0041\u0302",
-  // Â = \^{A}
-  "\u1ea4": "\u0041\u0302\u0301",
-  // Ấ = \^\'{A}
-  "\u1ea6": "\u0041\u0302\u0300",
-  // Ầ = \^\`{A}
-  "\u1eaa": "\u0041\u0302\u0303",
-  // Ẫ = \^\~{A}
-  "\u0226": "\u0041\u0307",
-  // Ȧ = \.{A}
-  "\u01e0": "\u0041\u0307\u0304",
-  // Ǡ = \.\={A}
-  "\u00c5": "\u0041\u030a",
-  // Å = \r{A}
-  "\u01fa": "\u0041\u030a\u0301",
-  // Ǻ = \r\'{A}
-  "\u1e02": "\u0042\u0307",
-  // Ḃ = \.{B}
-  "\u0106": "\u0043\u0301",
-  // Ć = \'{C}
-  "\u010c": "\u0043\u030c",
-  // Č = \v{C}
-  "\u0108": "\u0043\u0302",
-  // Ĉ = \^{C}
-  "\u010a": "\u0043\u0307",
-  // Ċ = \.{C}
-  "\u010e": "\u0044\u030c",
-  // Ď = \v{D}
-  "\u1e0a": "\u0044\u0307",
-  // Ḋ = \.{D}
-  "\u00c9": "\u0045\u0301",
-  // É = \'{E}
-  "\u00c8": "\u0045\u0300",
-  // È = \`{E}
-  "\u00cb": "\u0045\u0308",
-  // Ë = \"{E}
-  "\u1ebc": "\u0045\u0303",
-  // Ẽ = \~{E}
-  "\u0112": "\u0045\u0304",
-  // Ē = \={E}
-  "\u1e16": "\u0045\u0304\u0301",
-  // Ḗ = \=\'{E}
-  "\u1e14": "\u0045\u0304\u0300",
-  // Ḕ = \=\`{E}
-  "\u0114": "\u0045\u0306",
-  // Ĕ = \u{E}
-  "\u011a": "\u0045\u030c",
-  // Ě = \v{E}
-  "\u00ca": "\u0045\u0302",
-  // Ê = \^{E}
-  "\u1ebe": "\u0045\u0302\u0301",
-  // Ế = \^\'{E}
-  "\u1ec0": "\u0045\u0302\u0300",
-  // Ề = \^\`{E}
-  "\u1ec4": "\u0045\u0302\u0303",
-  // Ễ = \^\~{E}
-  "\u0116": "\u0045\u0307",
-  // Ė = \.{E}
-  "\u1e1e": "\u0046\u0307",
-  // Ḟ = \.{F}
-  "\u01f4": "\u0047\u0301",
-  // Ǵ = \'{G}
-  "\u1e20": "\u0047\u0304",
-  // Ḡ = \={G}
-  "\u011e": "\u0047\u0306",
-  // Ğ = \u{G}
-  "\u01e6": "\u0047\u030c",
-  // Ǧ = \v{G}
-  "\u011c": "\u0047\u0302",
-  // Ĝ = \^{G}
-  "\u0120": "\u0047\u0307",
-  // Ġ = \.{G}
-  "\u1e26": "\u0048\u0308",
-  // Ḧ = \"{H}
-  "\u021e": "\u0048\u030c",
-  // Ȟ = \v{H}
-  "\u0124": "\u0048\u0302",
-  // Ĥ = \^{H}
-  "\u1e22": "\u0048\u0307",
-  // Ḣ = \.{H}
-  "\u00cd": "\u0049\u0301",
-  // Í = \'{I}
-  "\u00cc": "\u0049\u0300",
-  // Ì = \`{I}
-  "\u00cf": "\u0049\u0308",
-  // Ï = \"{I}
-  "\u1e2e": "\u0049\u0308\u0301",
-  // Ḯ = \"\'{I}
-  "\u0128": "\u0049\u0303",
-  // Ĩ = \~{I}
-  "\u012a": "\u0049\u0304",
-  // Ī = \={I}
-  "\u012c": "\u0049\u0306",
-  // Ĭ = \u{I}
-  "\u01cf": "\u0049\u030c",
-  // Ǐ = \v{I}
-  "\u00ce": "\u0049\u0302",
-  // Î = \^{I}
-  "\u0130": "\u0049\u0307",
-  // İ = \.{I}
-  "\u0134": "\u004a\u0302",
-  // Ĵ = \^{J}
-  "\u1e30": "\u004b\u0301",
-  // Ḱ = \'{K}
-  "\u01e8": "\u004b\u030c",
-  // Ǩ = \v{K}
-  "\u0139": "\u004c\u0301",
-  // Ĺ = \'{L}
-  "\u013d": "\u004c\u030c",
-  // Ľ = \v{L}
-  "\u1e3e": "\u004d\u0301",
-  // Ḿ = \'{M}
-  "\u1e40": "\u004d\u0307",
-  // Ṁ = \.{M}
-  "\u0143": "\u004e\u0301",
-  // Ń = \'{N}
-  "\u01f8": "\u004e\u0300",
-  // Ǹ = \`{N}
-  "\u00d1": "\u004e\u0303",
-  // Ñ = \~{N}
-  "\u0147": "\u004e\u030c",
-  // Ň = \v{N}
-  "\u1e44": "\u004e\u0307",
-  // Ṅ = \.{N}
-  "\u00d3": "\u004f\u0301",
-  // Ó = \'{O}
-  "\u00d2": "\u004f\u0300",
-  // Ò = \`{O}
-  "\u00d6": "\u004f\u0308",
-  // Ö = \"{O}
-  "\u022a": "\u004f\u0308\u0304",
-  // Ȫ = \"\={O}
-  "\u00d5": "\u004f\u0303",
-  // Õ = \~{O}
-  "\u1e4c": "\u004f\u0303\u0301",
-  // Ṍ = \~\'{O}
-  "\u1e4e": "\u004f\u0303\u0308",
-  // Ṏ = \~\"{O}
-  "\u022c": "\u004f\u0303\u0304",
-  // Ȭ = \~\={O}
-  "\u014c": "\u004f\u0304",
-  // Ō = \={O}
-  "\u1e52": "\u004f\u0304\u0301",
-  // Ṓ = \=\'{O}
-  "\u1e50": "\u004f\u0304\u0300",
-  // Ṑ = \=\`{O}
-  "\u014e": "\u004f\u0306",
-  // Ŏ = \u{O}
-  "\u01d1": "\u004f\u030c",
-  // Ǒ = \v{O}
-  "\u00d4": "\u004f\u0302",
-  // Ô = \^{O}
-  "\u1ed0": "\u004f\u0302\u0301",
-  // Ố = \^\'{O}
-  "\u1ed2": "\u004f\u0302\u0300",
-  // Ồ = \^\`{O}
-  "\u1ed6": "\u004f\u0302\u0303",
-  // Ỗ = \^\~{O}
-  "\u022e": "\u004f\u0307",
-  // Ȯ = \.{O}
-  "\u0230": "\u004f\u0307\u0304",
-  // Ȱ = \.\={O}
-  "\u0150": "\u004f\u030b",
-  // Ő = \H{O}
-  "\u1e54": "\u0050\u0301",
-  // Ṕ = \'{P}
-  "\u1e56": "\u0050\u0307",
-  // Ṗ = \.{P}
-  "\u0154": "\u0052\u0301",
-  // Ŕ = \'{R}
-  "\u0158": "\u0052\u030c",
-  // Ř = \v{R}
-  "\u1e58": "\u0052\u0307",
-  // Ṙ = \.{R}
-  "\u015a": "\u0053\u0301",
-  // Ś = \'{S}
-  "\u1e64": "\u0053\u0301\u0307",
-  // Ṥ = \'\.{S}
-  "\u0160": "\u0053\u030c",
-  // Š = \v{S}
-  "\u1e66": "\u0053\u030c\u0307",
-  // Ṧ = \v\.{S}
-  "\u015c": "\u0053\u0302",
-  // Ŝ = \^{S}
-  "\u1e60": "\u0053\u0307",
-  // Ṡ = \.{S}
-  "\u0164": "\u0054\u030c",
-  // Ť = \v{T}
-  "\u1e6a": "\u0054\u0307",
-  // Ṫ = \.{T}
-  "\u00da": "\u0055\u0301",
-  // Ú = \'{U}
-  "\u00d9": "\u0055\u0300",
-  // Ù = \`{U}
-  "\u00dc": "\u0055\u0308",
-  // Ü = \"{U}
-  "\u01d7": "\u0055\u0308\u0301",
-  // Ǘ = \"\'{U}
-  "\u01db": "\u0055\u0308\u0300",
-  // Ǜ = \"\`{U}
-  "\u01d5": "\u0055\u0308\u0304",
-  // Ǖ = \"\={U}
-  "\u01d9": "\u0055\u0308\u030c",
-  // Ǚ = \"\v{U}
-  "\u0168": "\u0055\u0303",
-  // Ũ = \~{U}
-  "\u1e78": "\u0055\u0303\u0301",
-  // Ṹ = \~\'{U}
-  "\u016a": "\u0055\u0304",
-  // Ū = \={U}
-  "\u1e7a": "\u0055\u0304\u0308",
-  // Ṻ = \=\"{U}
-  "\u016c": "\u0055\u0306",
-  // Ŭ = \u{U}
-  "\u01d3": "\u0055\u030c",
-  // Ǔ = \v{U}
-  "\u00db": "\u0055\u0302",
-  // Û = \^{U}
-  "\u016e": "\u0055\u030a",
-  // Ů = \r{U}
-  "\u0170": "\u0055\u030b",
-  // Ű = \H{U}
-  "\u1e7c": "\u0056\u0303",
-  // Ṽ = \~{V}
-  "\u1e82": "\u0057\u0301",
-  // Ẃ = \'{W}
-  "\u1e80": "\u0057\u0300",
-  // Ẁ = \`{W}
-  "\u1e84": "\u0057\u0308",
-  // Ẅ = \"{W}
-  "\u0174": "\u0057\u0302",
-  // Ŵ = \^{W}
-  "\u1e86": "\u0057\u0307",
-  // Ẇ = \.{W}
-  "\u1e8c": "\u0058\u0308",
-  // Ẍ = \"{X}
-  "\u1e8a": "\u0058\u0307",
-  // Ẋ = \.{X}
-  "\u00dd": "\u0059\u0301",
-  // Ý = \'{Y}
-  "\u1ef2": "\u0059\u0300",
-  // Ỳ = \`{Y}
-  "\u0178": "\u0059\u0308",
-  // Ÿ = \"{Y}
-  "\u1ef8": "\u0059\u0303",
-  // Ỹ = \~{Y}
-  "\u0232": "\u0059\u0304",
-  // Ȳ = \={Y}
-  "\u0176": "\u0059\u0302",
-  // Ŷ = \^{Y}
-  "\u1e8e": "\u0059\u0307",
-  // Ẏ = \.{Y}
-  "\u0179": "\u005a\u0301",
-  // Ź = \'{Z}
-  "\u017d": "\u005a\u030c",
-  // Ž = \v{Z}
-  "\u1e90": "\u005a\u0302",
-  // Ẑ = \^{Z}
-  "\u017b": "\u005a\u0307",
-  // Ż = \.{Z}
-  "\u03ac": "\u03b1\u0301",
-  // ά = \'{α}
-  "\u1f70": "\u03b1\u0300",
-  // ὰ = \`{α}
-  "\u1fb1": "\u03b1\u0304",
-  // ᾱ = \={α}
-  "\u1fb0": "\u03b1\u0306",
-  // ᾰ = \u{α}
-  "\u03ad": "\u03b5\u0301",
-  // έ = \'{ε}
-  "\u1f72": "\u03b5\u0300",
-  // ὲ = \`{ε}
-  "\u03ae": "\u03b7\u0301",
-  // ή = \'{η}
-  "\u1f74": "\u03b7\u0300",
-  // ὴ = \`{η}
-  "\u03af": "\u03b9\u0301",
-  // ί = \'{ι}
-  "\u1f76": "\u03b9\u0300",
-  // ὶ = \`{ι}
-  "\u03ca": "\u03b9\u0308",
-  // ϊ = \"{ι}
-  "\u0390": "\u03b9\u0308\u0301",
-  // ΐ = \"\'{ι}
-  "\u1fd2": "\u03b9\u0308\u0300",
-  // ῒ = \"\`{ι}
-  "\u1fd1": "\u03b9\u0304",
-  // ῑ = \={ι}
-  "\u1fd0": "\u03b9\u0306",
-  // ῐ = \u{ι}
-  "\u03cc": "\u03bf\u0301",
-  // ό = \'{ο}
-  "\u1f78": "\u03bf\u0300",
-  // ὸ = \`{ο}
-  "\u03cd": "\u03c5\u0301",
-  // ύ = \'{υ}
-  "\u1f7a": "\u03c5\u0300",
-  // ὺ = \`{υ}
-  "\u03cb": "\u03c5\u0308",
-  // ϋ = \"{υ}
-  "\u03b0": "\u03c5\u0308\u0301",
-  // ΰ = \"\'{υ}
-  "\u1fe2": "\u03c5\u0308\u0300",
-  // ῢ = \"\`{υ}
-  "\u1fe1": "\u03c5\u0304",
-  // ῡ = \={υ}
-  "\u1fe0": "\u03c5\u0306",
-  // ῠ = \u{υ}
-  "\u03ce": "\u03c9\u0301",
-  // ώ = \'{ω}
-  "\u1f7c": "\u03c9\u0300",
-  // ὼ = \`{ω}
-  "\u038e": "\u03a5\u0301",
-  // Ύ = \'{Υ}
-  "\u1fea": "\u03a5\u0300",
-  // Ὺ = \`{Υ}
-  "\u03ab": "\u03a5\u0308",
-  // Ϋ = \"{Υ}
-  "\u1fe9": "\u03a5\u0304",
-  // Ῡ = \={Υ}
-  "\u1fe8": "\u03a5\u0306",
-  // Ῠ = \u{Υ}
-  "\u038f": "\u03a9\u0301",
-  // Ώ = \'{Ω}
-  "\u1ffa": "\u03a9\u0300" // Ὼ = \`{Ω}
-
+const unicodeSymbols = {
+  "á": "á",
+  "à": "à",
+  "ä": "ä",
+  "ǟ": "ǟ",
+  "ã": "ã",
+  "ā": "ā",
+  "ă": "ă",
+  "ắ": "ắ",
+  "ằ": "ằ",
+  "ẵ": "ẵ",
+  "ǎ": "ǎ",
+  "â": "â",
+  "ấ": "ấ",
+  "ầ": "ầ",
+  "ẫ": "ẫ",
+  "ȧ": "ȧ",
+  "ǡ": "ǡ",
+  "å": "å",
+  "ǻ": "ǻ",
+  "ḃ": "ḃ",
+  "ć": "ć",
+  "č": "č",
+  "ĉ": "ĉ",
+  "ċ": "ċ",
+  "ď": "ď",
+  "ḋ": "ḋ",
+  "é": "é",
+  "è": "è",
+  "ë": "ë",
+  "ẽ": "ẽ",
+  "ē": "ē",
+  "ḗ": "ḗ",
+  "ḕ": "ḕ",
+  "ĕ": "ĕ",
+  "ě": "ě",
+  "ê": "ê",
+  "ế": "ế",
+  "ề": "ề",
+  "ễ": "ễ",
+  "ė": "ė",
+  "ḟ": "ḟ",
+  "ǵ": "ǵ",
+  "ḡ": "ḡ",
+  "ğ": "ğ",
+  "ǧ": "ǧ",
+  "ĝ": "ĝ",
+  "ġ": "ġ",
+  "ḧ": "ḧ",
+  "ȟ": "ȟ",
+  "ĥ": "ĥ",
+  "ḣ": "ḣ",
+  "í": "í",
+  "ì": "ì",
+  "ï": "ï",
+  "ḯ": "ḯ",
+  "ĩ": "ĩ",
+  "ī": "ī",
+  "ĭ": "ĭ",
+  "ǐ": "ǐ",
+  "î": "î",
+  "ǰ": "ǰ",
+  "ĵ": "ĵ",
+  "ḱ": "ḱ",
+  "ǩ": "ǩ",
+  "ĺ": "ĺ",
+  "ľ": "ľ",
+  "ḿ": "ḿ",
+  "ṁ": "ṁ",
+  "ń": "ń",
+  "ǹ": "ǹ",
+  "ñ": "ñ",
+  "ň": "ň",
+  "ṅ": "ṅ",
+  "ó": "ó",
+  "ò": "ò",
+  "ö": "ö",
+  "ȫ": "ȫ",
+  "õ": "õ",
+  "ṍ": "ṍ",
+  "ṏ": "ṏ",
+  "ȭ": "ȭ",
+  "ō": "ō",
+  "ṓ": "ṓ",
+  "ṑ": "ṑ",
+  "ŏ": "ŏ",
+  "ǒ": "ǒ",
+  "ô": "ô",
+  "ố": "ố",
+  "ồ": "ồ",
+  "ỗ": "ỗ",
+  "ȯ": "ȯ",
+  "ȱ": "ȱ",
+  "ő": "ő",
+  "ṕ": "ṕ",
+  "ṗ": "ṗ",
+  "ŕ": "ŕ",
+  "ř": "ř",
+  "ṙ": "ṙ",
+  "ś": "ś",
+  "ṥ": "ṥ",
+  "š": "š",
+  "ṧ": "ṧ",
+  "ŝ": "ŝ",
+  "ṡ": "ṡ",
+  "ẗ": "ẗ",
+  "ť": "ť",
+  "ṫ": "ṫ",
+  "ú": "ú",
+  "ù": "ù",
+  "ü": "ü",
+  "ǘ": "ǘ",
+  "ǜ": "ǜ",
+  "ǖ": "ǖ",
+  "ǚ": "ǚ",
+  "ũ": "ũ",
+  "ṹ": "ṹ",
+  "ū": "ū",
+  "ṻ": "ṻ",
+  "ŭ": "ŭ",
+  "ǔ": "ǔ",
+  "û": "û",
+  "ů": "ů",
+  "ű": "ű",
+  "ṽ": "ṽ",
+  "ẃ": "ẃ",
+  "ẁ": "ẁ",
+  "ẅ": "ẅ",
+  "ŵ": "ŵ",
+  "ẇ": "ẇ",
+  "ẘ": "ẘ",
+  "ẍ": "ẍ",
+  "ẋ": "ẋ",
+  "ý": "ý",
+  "ỳ": "ỳ",
+  "ÿ": "ÿ",
+  "ỹ": "ỹ",
+  "ȳ": "ȳ",
+  "ŷ": "ŷ",
+  "ẏ": "ẏ",
+  "ẙ": "ẙ",
+  "ź": "ź",
+  "ž": "ž",
+  "ẑ": "ẑ",
+  "ż": "ż",
+  "Á": "Á",
+  "À": "À",
+  "Ä": "Ä",
+  "Ǟ": "Ǟ",
+  "Ã": "Ã",
+  "Ā": "Ā",
+  "Ă": "Ă",
+  "Ắ": "Ắ",
+  "Ằ": "Ằ",
+  "Ẵ": "Ẵ",
+  "Ǎ": "Ǎ",
+  "Â": "Â",
+  "Ấ": "Ấ",
+  "Ầ": "Ầ",
+  "Ẫ": "Ẫ",
+  "Ȧ": "Ȧ",
+  "Ǡ": "Ǡ",
+  "Å": "Å",
+  "Ǻ": "Ǻ",
+  "Ḃ": "Ḃ",
+  "Ć": "Ć",
+  "Č": "Č",
+  "Ĉ": "Ĉ",
+  "Ċ": "Ċ",
+  "Ď": "Ď",
+  "Ḋ": "Ḋ",
+  "É": "É",
+  "È": "È",
+  "Ë": "Ë",
+  "Ẽ": "Ẽ",
+  "Ē": "Ē",
+  "Ḗ": "Ḗ",
+  "Ḕ": "Ḕ",
+  "Ĕ": "Ĕ",
+  "Ě": "Ě",
+  "Ê": "Ê",
+  "Ế": "Ế",
+  "Ề": "Ề",
+  "Ễ": "Ễ",
+  "Ė": "Ė",
+  "Ḟ": "Ḟ",
+  "Ǵ": "Ǵ",
+  "Ḡ": "Ḡ",
+  "Ğ": "Ğ",
+  "Ǧ": "Ǧ",
+  "Ĝ": "Ĝ",
+  "Ġ": "Ġ",
+  "Ḧ": "Ḧ",
+  "Ȟ": "Ȟ",
+  "Ĥ": "Ĥ",
+  "Ḣ": "Ḣ",
+  "Í": "Í",
+  "Ì": "Ì",
+  "Ï": "Ï",
+  "Ḯ": "Ḯ",
+  "Ĩ": "Ĩ",
+  "Ī": "Ī",
+  "Ĭ": "Ĭ",
+  "Ǐ": "Ǐ",
+  "Î": "Î",
+  "İ": "İ",
+  "Ĵ": "Ĵ",
+  "Ḱ": "Ḱ",
+  "Ǩ": "Ǩ",
+  "Ĺ": "Ĺ",
+  "Ľ": "Ľ",
+  "Ḿ": "Ḿ",
+  "Ṁ": "Ṁ",
+  "Ń": "Ń",
+  "Ǹ": "Ǹ",
+  "Ñ": "Ñ",
+  "Ň": "Ň",
+  "Ṅ": "Ṅ",
+  "Ó": "Ó",
+  "Ò": "Ò",
+  "Ö": "Ö",
+  "Ȫ": "Ȫ",
+  "Õ": "Õ",
+  "Ṍ": "Ṍ",
+  "Ṏ": "Ṏ",
+  "Ȭ": "Ȭ",
+  "Ō": "Ō",
+  "Ṓ": "Ṓ",
+  "Ṑ": "Ṑ",
+  "Ŏ": "Ŏ",
+  "Ǒ": "Ǒ",
+  "Ô": "Ô",
+  "Ố": "Ố",
+  "Ồ": "Ồ",
+  "Ỗ": "Ỗ",
+  "Ȯ": "Ȯ",
+  "Ȱ": "Ȱ",
+  "Ő": "Ő",
+  "Ṕ": "Ṕ",
+  "Ṗ": "Ṗ",
+  "Ŕ": "Ŕ",
+  "Ř": "Ř",
+  "Ṙ": "Ṙ",
+  "Ś": "Ś",
+  "Ṥ": "Ṥ",
+  "Š": "Š",
+  "Ṧ": "Ṧ",
+  "Ŝ": "Ŝ",
+  "Ṡ": "Ṡ",
+  "Ť": "Ť",
+  "Ṫ": "Ṫ",
+  "Ú": "Ú",
+  "Ù": "Ù",
+  "Ü": "Ü",
+  "Ǘ": "Ǘ",
+  "Ǜ": "Ǜ",
+  "Ǖ": "Ǖ",
+  "Ǚ": "Ǚ",
+  "Ũ": "Ũ",
+  "Ṹ": "Ṹ",
+  "Ū": "Ū",
+  "Ṻ": "Ṻ",
+  "Ŭ": "Ŭ",
+  "Ǔ": "Ǔ",
+  "Û": "Û",
+  "Ů": "Ů",
+  "Ű": "Ű",
+  "Ṽ": "Ṽ",
+  "Ẃ": "Ẃ",
+  "Ẁ": "Ẁ",
+  "Ẅ": "Ẅ",
+  "Ŵ": "Ŵ",
+  "Ẇ": "Ẇ",
+  "Ẍ": "Ẍ",
+  "Ẋ": "Ẋ",
+  "Ý": "Ý",
+  "Ỳ": "Ỳ",
+  "Ÿ": "Ÿ",
+  "Ỹ": "Ỹ",
+  "Ȳ": "Ȳ",
+  "Ŷ": "Ŷ",
+  "Ẏ": "Ẏ",
+  "Ź": "Ź",
+  "Ž": "Ž",
+  "Ẑ": "Ẑ",
+  "Ż": "Ż",
+  "ά": "ά",
+  "ὰ": "ὰ",
+  "ᾱ": "ᾱ",
+  "ᾰ": "ᾰ",
+  "έ": "έ",
+  "ὲ": "ὲ",
+  "ή": "ή",
+  "ὴ": "ὴ",
+  "ί": "ί",
+  "ὶ": "ὶ",
+  "ϊ": "ϊ",
+  "ΐ": "ΐ",
+  "ῒ": "ῒ",
+  "ῑ": "ῑ",
+  "ῐ": "ῐ",
+  "ό": "ό",
+  "ὸ": "ὸ",
+  "ύ": "ύ",
+  "ὺ": "ὺ",
+  "ϋ": "ϋ",
+  "ΰ": "ΰ",
+  "ῢ": "ῢ",
+  "ῡ": "ῡ",
+  "ῠ": "ῠ",
+  "ώ": "ώ",
+  "ὼ": "ὼ",
+  "Ύ": "Ύ",
+  "Ὺ": "Ὺ",
+  "Ϋ": "Ϋ",
+  "Ῡ": "Ῡ",
+  "Ῠ": "Ῠ",
+  "Ώ": "Ώ",
+  "Ὼ": "Ὼ"
 };
 
-/* eslint no-constant-condition:0 */
-
 /**
  * This file contains the parser used to parse out a TeX expression from the
  * input. Since TeX isn't context-free, standard parsers don't work particularly
@@ -15831,12 +15721,15 @@ class Parser {
 
 
   parse() {
-    // Create a group namespace for the math expression.
-    // (LaTeX creates a new group for every $...$, $$...$$, \[...\].)
-    this.gullet.beginGroup(); // Use old \color behavior (same as LaTeX's \textcolor) if requested.
+    if (!this.settings.globalGroup) {
+      // Create a group namespace for the math expression.
+      // (LaTeX creates a new group for every $...$, $$...$$, \[...\].)
+      this.gullet.beginGroup();
+    } // Use old \color behavior (same as LaTeX's \textcolor) if requested.
     // We do this within the group for the math expression, so it doesn't
     // pollute settings.macros.
 
+
     if (this.settings.colorIsTextColor) {
       this.gullet.macros.set("\\color", "\\textcolor");
     } // Try to parse the input
@@ -15846,7 +15739,10 @@ class Parser {
 
     this.expect("EOF"); // End the group namespace for the expression
 
-    this.gullet.endGroup();
+    if (!this.settings.globalGroup) {
+      this.gullet.endGroup();
+    }
+
     return parse;
   }
 
@@ -15878,6 +15774,8 @@ class Parser {
 
       if (!atom) {
         break;
+      } else if (atom.type === "internal") {
+        continue;
       }
 
       body.push(atom);
@@ -15903,15 +15801,13 @@ class Parser {
     let funcName;
 
     for (let i = 0; i < body.length; i++) {
-      const node = checkNodeType(body[i], "infix");
-
-      if (node) {
+      if (body[i].type === "infix") {
         if (overIndex !== -1) {
-          throw new ParseError("only one infix operator per group", node.token);
+          throw new ParseError("only one infix operator per group", body[i].token);
         }
 
         overIndex = i;
-        funcName = node.replaceWith;
+        funcName = body[i].replaceWith;
       }
     }
 
@@ -16027,21 +15923,15 @@ class Parser {
 
       if (lex.text === "\\limits" || lex.text === "\\nolimits") {
         // We got a limit control
-        let opNode = checkNodeType(base, "op");
-
-        if (opNode) {
+        if (base && base.type === "op") {
           const limits = lex.text === "\\limits";
-          opNode.limits = limits;
-          opNode.alwaysHandleSupSub = true;
+          base.limits = limits;
+          base.alwaysHandleSupSub = true;
+        } else if (base && base.type === "operatorname" && base.alwaysHandleSupSub) {
+          const limits = lex.text === "\\limits";
+          base.limits = limits;
         } else {
-          opNode = checkNodeType(base, "operatorname");
-
-          if (opNode && opNode.alwaysHandleSupSub) {
-            const limits = lex.text === "\\limits";
-            opNode.limits = limits;
-          } else {
-            throw new ParseError("Limit controls must follow a math operator", lex);
-          }
+          throw new ParseError("Limit controls must follow a math operator", lex);
         }
 
         this.consume();
@@ -16936,7 +16826,7 @@ var katex = {
   /**
    * Current KaTeX version
    */
-  version: "0.11.1",
+  version: "0.12.0",
 
   /**
    * Renders the given LaTeX into an HTML+MathML combination, and adds