jekyll-theme-hydejack 9.1.0 → 9.1.1

data/assets/bower_components/katex/dist/katex.js

@@ -177,14 +177,10 @@ function () {
 var Token_Token =
 /*#__PURE__*/
 function () {
-  // don't expand the token
-  // used in \noexpand
   function Token(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;
   }
@@ -422,7 +418,6 @@ function () {
     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);
@@ -438,7 +433,6 @@ function () {
     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.
@@ -850,9 +844,6 @@ var sqrtPath = function sqrtPath(size, extraViniculum, viewBoxHeight) {
   return path;
 };
 var svgGeometry_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\nl10-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\n 0-12.2.5-14.5 1.5-2.3 1-4.8 4.5-7.5 10.5-49.3 97.3-121.7 169.3-217 216-28\n 14-57.3 25-88 33-6.7 2-11 3.8-13 5.5-2 1.7-3 4.2-3 7.5s1 5.8 3 7.5\nc2 1.7 6.3 3.5 13 5.5 68 17.3 128.2 47.8 180.5 91.5 52.3 43.7 93.8 96.2 124.5\n 157.5 9.3 8 15.3 12.3 18 13h6c12-.7 18-4 18-10 0-2-1.7-7-5-15-23.3-46-52-87\n-86-123l-10-10h399738v-40H218c328 0 0 0 0 0l-10-8c-26.7-20-65.7-43-117-69 2.7\n-2 6-3.7 10-5 36.7-16 72.3-37.3 107-64l10-8h399782v-40z\nm8 0v40h399730v-40zm0 194v40h399730v-40z",
   // doublerightarrow is from glyph U+21D2 in font KaTeX Main
@@ -1577,7 +1568,6 @@ function assertSpan(group) {
 // This file is GENERATED by buildMetrics.sh. DO NOT MODIFY.
 /* harmony default export */ var fontMetricsData = ({
   "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],
@@ -1605,7 +1595,6 @@ function assertSpan(group) {
     "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],
@@ -1836,7 +1825,16 @@ function assertSpan(group) {
     "57371": [0.13597, 0.63597, 0, 0, 0.77778]
   },
   "Caligraphic-Regular": {
-    "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.19445, 0.79847],
     "66": [0, 0.68333, 0.03041, 0.13889, 0.65681],
     "67": [0, 0.68333, 0.05834, 0.13889, 0.52653],
@@ -1862,11 +1860,9 @@ function assertSpan(group) {
     "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],
-    "160": [0, 0, 0, 0, 0.25]
+    "90": [0, 0.68333, 0.07944, 0.13889, 0.72473]
   },
   "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],
@@ -1948,7 +1944,6 @@ function assertSpan(group) {
     "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],
@@ -1961,7 +1956,6 @@ function assertSpan(group) {
     "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],
@@ -2055,8 +2049,6 @@ function assertSpan(group) {
     "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],
@@ -2214,7 +2206,6 @@ function assertSpan(group) {
     "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],
@@ -2301,7 +2292,7 @@ function assertSpan(group) {
     "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],
-    "160": [0, 0, 0, 0, 0.25],
+    "163": [0, 0.69444, 0, 0, 0.86853],
     "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],
@@ -2343,7 +2334,6 @@ function assertSpan(group) {
     "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],
@@ -2430,7 +2420,7 @@ function assertSpan(group) {
     "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],
-    "160": [0, 0, 0, 0, 0.25],
+    "163": [0, 0.69444, 0, 0, 0.76909],
     "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],
@@ -2439,8 +2429,10 @@ function assertSpan(group) {
     "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],
@@ -2566,7 +2558,6 @@ function assertSpan(group) {
     "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],
@@ -2749,17 +2740,6 @@ function assertSpan(group) {
     "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],
@@ -2812,7 +2792,6 @@ function assertSpan(group) {
     "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],
@@ -2853,22 +2832,9 @@ function assertSpan(group) {
     "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],
-    "57649": [0, 0.44444, 0, 0, 0.39352],
-    "57911": [0.19444, 0.44444, 0, 0, 0.43889]
+    "1013": [0, 0.44444, 0, 0, 0.48333]
   },
   "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],
@@ -2921,7 +2887,6 @@ function assertSpan(group) {
     "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],
@@ -2962,12 +2927,104 @@ function assertSpan(group) {
     "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],
-    "57649": [0, 0.43056, 0, 0.02778, 0.32246],
-    "57911": [0.19444, 0.43056, 0, 0.08334, 0.38403]
+    "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]
   },
   "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],
@@ -3055,7 +3112,6 @@ function assertSpan(group) {
     "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],
@@ -3089,7 +3145,6 @@ function assertSpan(group) {
     "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],
@@ -3177,7 +3232,6 @@ function assertSpan(group) {
     "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],
@@ -3212,7 +3266,6 @@ function assertSpan(group) {
     "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],
@@ -3300,7 +3353,6 @@ function assertSpan(group) {
     "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],
@@ -3335,7 +3387,6 @@ function assertSpan(group) {
     "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],
@@ -3361,11 +3412,9 @@ function assertSpan(group) {
     "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],
-    "160": [0, 0, 0, 0, 0.25]
+    "90": [0, 0.7, 0.24037, 0, 0.8212]
   },
   "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],
@@ -3374,7 +3423,6 @@ function assertSpan(group) {
     "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],
@@ -3412,7 +3460,6 @@ function assertSpan(group) {
     "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],
@@ -3421,7 +3468,6 @@ function assertSpan(group) {
     "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],
@@ -3451,7 +3497,6 @@ function assertSpan(group) {
     "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],
@@ -3460,7 +3505,6 @@ function assertSpan(group) {
     "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],
@@ -3474,7 +3518,6 @@ function assertSpan(group) {
     "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],
@@ -3483,7 +3526,6 @@ function assertSpan(group) {
     "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],
@@ -4196,10 +4238,9 @@ defineSymbol(symbols_math, ams, symbols_textord, "\u25A0", "\\blacksquare");
 defineSymbol(symbols_math, ams, symbols_textord, "\u29EB", "\\blacklozenge");
 defineSymbol(symbols_math, ams, symbols_textord, "\u2605", "\\bigstar");
 defineSymbol(symbols_math, ams, symbols_textord, "\u2222", "\\sphericalangle", true);
-defineSymbol(symbols_math, ams, symbols_textord, "\u2201", "\\complement", true); // unicode-math maps U+F0 to \matheth. We map to AMS function \eth
+defineSymbol(symbols_math, ams, symbols_textord, "\u2201", "\\complement", true); // unicode-math maps U+F0 (ð) to \matheth. We map to AMS function \eth
 
 defineSymbol(symbols_math, ams, symbols_textord, "\xF0", "\\eth", true);
-defineSymbol(symbols_text, main, symbols_textord, "\xF0", "\xF0");
 defineSymbol(symbols_math, ams, symbols_textord, "\u2571", "\\diagup");
 defineSymbol(symbols_math, ams, symbols_textord, "\u2572", "\\diagdown");
 defineSymbol(symbols_math, ams, symbols_textord, "\u25A1", "\\square");
@@ -4218,10 +4259,10 @@ defineSymbol(symbols_math, ams, symbols_textord, "\u2137", "\\gimel", true); //
 defineSymbol(symbols_math, ams, symbols_textord, "\u03DD", "\\digamma", true);
 defineSymbol(symbols_math, ams, symbols_textord, "\u03F0", "\\varkappa"); // AMS Delimiters
 
-defineSymbol(symbols_math, ams, symbols_open, "\u250C", "\\@ulcorner", true);
-defineSymbol(symbols_math, ams, symbols_close, "\u2510", "\\@urcorner", true);
-defineSymbol(symbols_math, ams, symbols_open, "\u2514", "\\@llcorner", true);
-defineSymbol(symbols_math, ams, symbols_close, "\u2518", "\\@lrcorner", true); // AMS Binary Relations
+defineSymbol(symbols_math, ams, symbols_open, "\u250C", "\\ulcorner", true);
+defineSymbol(symbols_math, ams, symbols_close, "\u2510", "\\urcorner", true);
+defineSymbol(symbols_math, ams, symbols_open, "\u2514", "\\llcorner", true);
+defineSymbol(symbols_math, ams, symbols_close, "\u2518", "\\lrcorner", true); // AMS Binary Relations
 
 defineSymbol(symbols_math, ams, rel, "\u2266", "\\leqq", true);
 defineSymbol(symbols_math, ams, rel, "\u2A7D", "\\leqslant", true);
@@ -4449,22 +4490,28 @@ defineSymbol(symbols_math, main, bin, "\u2228", "\\lor");
 defineSymbol(symbols_math, main, bin, "\u2227", "\\wedge", true);
 defineSymbol(symbols_math, main, bin, "\u2228", "\\vee", true);
 defineSymbol(symbols_math, main, symbols_textord, "\u221A", "\\surd");
+defineSymbol(symbols_math, main, symbols_open, "(", "(");
+defineSymbol(symbols_math, main, symbols_open, "[", "[");
 defineSymbol(symbols_math, main, symbols_open, "\u27E8", "\\langle", true);
 defineSymbol(symbols_math, main, symbols_open, "\u2223", "\\lvert");
 defineSymbol(symbols_math, main, symbols_open, "\u2225", "\\lVert");
+defineSymbol(symbols_math, main, symbols_close, ")", ")");
+defineSymbol(symbols_math, main, symbols_close, "]", "]");
 defineSymbol(symbols_math, main, symbols_close, "?", "?");
 defineSymbol(symbols_math, main, symbols_close, "!", "!");
 defineSymbol(symbols_math, main, symbols_close, "\u27E9", "\\rangle", true);
 defineSymbol(symbols_math, main, symbols_close, "\u2223", "\\rvert");
 defineSymbol(symbols_math, main, symbols_close, "\u2225", "\\rVert");
 defineSymbol(symbols_math, main, rel, "=", "=");
+defineSymbol(symbols_math, main, rel, "<", "<");
+defineSymbol(symbols_math, main, rel, ">", ">");
 defineSymbol(symbols_math, main, rel, ":", ":");
 defineSymbol(symbols_math, main, rel, "\u2248", "\\approx", true);
 defineSymbol(symbols_math, main, rel, "\u2245", "\\cong", true);
 defineSymbol(symbols_math, main, rel, "\u2265", "\\ge");
 defineSymbol(symbols_math, main, rel, "\u2265", "\\geq", true);
 defineSymbol(symbols_math, main, rel, "\u2190", "\\gets");
-defineSymbol(symbols_math, main, rel, ">", "\\gt", true);
+defineSymbol(symbols_math, main, rel, ">", "\\gt");
 defineSymbol(symbols_math, main, rel, "\u2208", "\\in", true);
 defineSymbol(symbols_math, main, rel, "\uE020", "\\@not");
 defineSymbol(symbols_math, main, rel, "\u2282", "\\subset", true);
@@ -4477,7 +4524,7 @@ defineSymbol(symbols_math, main, rel, "\u22A8", "\\models");
 defineSymbol(symbols_math, main, rel, "\u2190", "\\leftarrow", true);
 defineSymbol(symbols_math, main, rel, "\u2264", "\\le");
 defineSymbol(symbols_math, main, rel, "\u2264", "\\leq", true);
-defineSymbol(symbols_math, main, rel, "<", "\\lt", true);
+defineSymbol(symbols_math, main, rel, "<", "\\lt");
 defineSymbol(symbols_math, main, rel, "\u2192", "\\rightarrow", true);
 defineSymbol(symbols_math, main, rel, "\u2192", "\\to");
 defineSymbol(symbols_math, ams, rel, "\u2271", "\\ngeq", true);
@@ -4488,7 +4535,6 @@ defineSymbol(symbols_math, main, symbols_spacing, "\xA0", "\\space"); // Ref: La
 
 defineSymbol(symbols_math, main, symbols_spacing, "\xA0", "\\nobreakspace");
 defineSymbol(symbols_text, main, symbols_spacing, "\xA0", "\\ ");
-defineSymbol(symbols_text, main, symbols_spacing, "\xA0", " ");
 defineSymbol(symbols_text, main, symbols_spacing, "\xA0", "~");
 defineSymbol(symbols_text, main, symbols_spacing, "\xA0", "\\space");
 defineSymbol(symbols_text, main, symbols_spacing, "\xA0", "\\nobreakspace");
@@ -4520,15 +4566,15 @@ defineSymbol(symbols_text, main, symbols_textord, "}", "\\}");
 defineSymbol(symbols_text, main, symbols_textord, "}", "\\textbraceright");
 defineSymbol(symbols_math, main, symbols_open, "{", "\\lbrace");
 defineSymbol(symbols_math, main, symbols_close, "}", "\\rbrace");
-defineSymbol(symbols_math, main, symbols_open, "[", "\\lbrack", true);
-defineSymbol(symbols_text, main, symbols_textord, "[", "\\lbrack", true);
-defineSymbol(symbols_math, main, symbols_close, "]", "\\rbrack", true);
-defineSymbol(symbols_text, main, symbols_textord, "]", "\\rbrack", true);
-defineSymbol(symbols_math, main, symbols_open, "(", "\\lparen", true);
-defineSymbol(symbols_math, main, symbols_close, ")", "\\rparen", true);
-defineSymbol(symbols_text, main, symbols_textord, "<", "\\textless", true); // in T1 fontenc
+defineSymbol(symbols_math, main, symbols_open, "[", "\\lbrack");
+defineSymbol(symbols_text, main, symbols_textord, "[", "\\lbrack");
+defineSymbol(symbols_math, main, symbols_close, "]", "\\rbrack");
+defineSymbol(symbols_text, main, symbols_textord, "]", "\\rbrack");
+defineSymbol(symbols_math, main, symbols_open, "(", "\\lparen");
+defineSymbol(symbols_math, main, symbols_close, ")", "\\rparen");
+defineSymbol(symbols_text, main, symbols_textord, "<", "\\textless"); // in T1 fontenc
 
-defineSymbol(symbols_text, main, symbols_textord, ">", "\\textgreater", true); // in T1 fontenc
+defineSymbol(symbols_text, main, symbols_textord, ">", "\\textgreater"); // in T1 fontenc
 
 defineSymbol(symbols_math, main, symbols_open, "\u230A", "\\lfloor", true);
 defineSymbol(symbols_math, main, symbols_close, "\u230B", "\\rfloor", true);
@@ -4537,7 +4583,7 @@ defineSymbol(symbols_math, main, symbols_close, "\u2309", "\\rceil", true);
 defineSymbol(symbols_math, main, symbols_textord, "\\", "\\backslash");
 defineSymbol(symbols_math, main, symbols_textord, "\u2223", "|");
 defineSymbol(symbols_math, main, symbols_textord, "\u2223", "\\vert");
-defineSymbol(symbols_text, main, symbols_textord, "|", "\\textbar", true); // in T1 fontenc
+defineSymbol(symbols_text, main, symbols_textord, "|", "\\textbar"); // in T1 fontenc
 
 defineSymbol(symbols_math, main, symbols_textord, "\u2225", "\\|");
 defineSymbol(symbols_math, main, symbols_textord, "\u2225", "\\Vert");
@@ -4567,6 +4613,8 @@ defineSymbol(symbols_math, main, op, "\u2A02", "\\bigotimes");
 defineSymbol(symbols_math, main, op, "\u2A01", "\\bigoplus");
 defineSymbol(symbols_math, main, op, "\u2A00", "\\bigodot");
 defineSymbol(symbols_math, main, op, "\u222E", "\\oint");
+defineSymbol(symbols_math, main, op, "\u222F", "\\oiint");
+defineSymbol(symbols_math, main, op, "\u2230", "\\oiiint");
 defineSymbol(symbols_math, main, op, "\u2A06", "\\bigsqcup");
 defineSymbol(symbols_math, main, op, "\u222B", "\\smallint");
 defineSymbol(symbols_text, main, symbols_inner, "\u2026", "\\textellipsis");
@@ -4587,16 +4635,14 @@ defineSymbol(symbols_math, main, symbols_accent, "\u02C7", "\\check");
 defineSymbol(symbols_math, main, symbols_accent, "^", "\\hat");
 defineSymbol(symbols_math, main, symbols_accent, "\u20D7", "\\vec");
 defineSymbol(symbols_math, main, symbols_accent, "\u02D9", "\\dot");
-defineSymbol(symbols_math, main, symbols_accent, "\u02DA", "\\mathring"); // \imath and \jmath should be invariant to \mathrm, \mathbf, etc., so use PUA
-
-defineSymbol(symbols_math, main, mathord, "\uE131", "\\@imath");
-defineSymbol(symbols_math, main, mathord, "\uE237", "\\@jmath");
-defineSymbol(symbols_math, main, symbols_textord, "\u0131", "\u0131");
-defineSymbol(symbols_math, main, symbols_textord, "\u0237", "\u0237");
+defineSymbol(symbols_math, main, symbols_accent, "\u02DA", "\\mathring");
+defineSymbol(symbols_math, main, mathord, "\u0131", "\\imath", true);
+defineSymbol(symbols_math, main, mathord, "\u0237", "\\jmath", true);
 defineSymbol(symbols_text, main, symbols_textord, "\u0131", "\\i", true);
 defineSymbol(symbols_text, main, symbols_textord, "\u0237", "\\j", true);
 defineSymbol(symbols_text, main, symbols_textord, "\xDF", "\\ss", true);
 defineSymbol(symbols_text, main, symbols_textord, "\xE6", "\\ae", true);
+defineSymbol(symbols_text, main, symbols_textord, "\xE6", "\\ae", true);
 defineSymbol(symbols_text, main, symbols_textord, "\u0153", "\\oe", true);
 defineSymbol(symbols_text, main, symbols_textord, "\xF8", "\\o", true);
 defineSymbol(symbols_text, main, symbols_textord, "\xC6", "\\AE", true);
@@ -4633,31 +4679,34 @@ var ligatures = {
   "``": true,
   "''": true
 };
-defineSymbol(symbols_text, main, symbols_textord, "\u2013", "--", true);
+defineSymbol(symbols_text, main, symbols_textord, "\u2013", "--");
 defineSymbol(symbols_text, main, symbols_textord, "\u2013", "\\textendash");
-defineSymbol(symbols_text, main, symbols_textord, "\u2014", "---", true);
+defineSymbol(symbols_text, main, symbols_textord, "\u2014", "---");
 defineSymbol(symbols_text, main, symbols_textord, "\u2014", "\\textemdash");
-defineSymbol(symbols_text, main, symbols_textord, "\u2018", "`", true);
+defineSymbol(symbols_text, main, symbols_textord, "\u2018", "`");
 defineSymbol(symbols_text, main, symbols_textord, "\u2018", "\\textquoteleft");
-defineSymbol(symbols_text, main, symbols_textord, "\u2019", "'", true);
+defineSymbol(symbols_text, main, symbols_textord, "\u2019", "'");
 defineSymbol(symbols_text, main, symbols_textord, "\u2019", "\\textquoteright");
-defineSymbol(symbols_text, main, symbols_textord, "\u201C", "``", true);
+defineSymbol(symbols_text, main, symbols_textord, "\u201C", "``");
 defineSymbol(symbols_text, main, symbols_textord, "\u201C", "\\textquotedblleft");
-defineSymbol(symbols_text, main, symbols_textord, "\u201D", "''", true);
+defineSymbol(symbols_text, main, symbols_textord, "\u201D", "''");
 defineSymbol(symbols_text, main, symbols_textord, "\u201D", "\\textquotedblright"); //  \degree from gensymb package
 
 defineSymbol(symbols_math, main, symbols_textord, "\xB0", "\\degree", true);
 defineSymbol(symbols_text, main, symbols_textord, "\xB0", "\\degree"); // \textdegree from inputenc package
 
 defineSymbol(symbols_text, main, symbols_textord, "\xB0", "\\textdegree", true); // TODO: In LaTeX, \pounds can generate a different character in text and math
-// mode, but among our fonts, only Main-Regular defines this character "163".
+// mode, but among our fonts, only Main-Italic defines this character "163".
 
-defineSymbol(symbols_math, main, symbols_textord, "\xA3", "\\pounds");
-defineSymbol(symbols_math, main, symbols_textord, "\xA3", "\\mathsterling", true);
-defineSymbol(symbols_text, main, symbols_textord, "\xA3", "\\pounds");
-defineSymbol(symbols_text, main, symbols_textord, "\xA3", "\\textsterling", true);
+defineSymbol(symbols_math, main, mathord, "\xA3", "\\pounds");
+defineSymbol(symbols_math, main, mathord, "\xA3", "\\mathsterling", true);
+defineSymbol(symbols_text, main, mathord, "\xA3", "\\pounds");
+defineSymbol(symbols_text, main, mathord, "\xA3", "\\textsterling", true);
 defineSymbol(symbols_math, ams, symbols_textord, "\u2720", "\\maltese");
-defineSymbol(symbols_text, ams, symbols_textord, "\u2720", "\\maltese"); // There are lots of symbols which are the same, so we add them in afterwards.
+defineSymbol(symbols_text, ams, symbols_textord, "\u2720", "\\maltese");
+defineSymbol(symbols_text, main, symbols_spacing, "\xA0", "\\ ");
+defineSymbol(symbols_text, main, symbols_spacing, "\xA0", " ");
+defineSymbol(symbols_text, main, symbols_spacing, "\xA0", "~"); // There are lots of symbols which are the same, so we add them in afterwards.
 // All of these are textords in math mode
 
 var mathTextSymbols = "0123456789/@.\"";
@@ -4668,7 +4717,7 @@ for (var symbols_i = 0; symbols_i < mathTextSymbols.length; symbols_i++) {
 } // All of these are textords in text mode
 
 
-var textSymbols = "0123456789!@*()-=+\";:?/.,";
+var textSymbols = "0123456789!@*()-=+[]<>|\";:?/.,";
 
 for (var src_symbols_i = 0; src_symbols_i < textSymbols.length; src_symbols_i++) {
   var _ch = textSymbols.charAt(src_symbols_i);
@@ -4797,7 +4846,7 @@ for (var symbols_i4 = 0; symbols_i4 < 10; symbols_i4++) {
 // TODO(edemaine): Fix this.
 
 
-var extraLatin = "\xC7\xD0\xDE\xE7\xFE";
+var extraLatin = "ÇÐÞçþ";
 
 for (var _i5 = 0; _i5 < extraLatin.length; _i5++) {
   var _ch5 = extraLatin.charAt(_i5);
@@ -4805,6 +4854,15 @@ for (var _i5 = 0; _i5 < extraLatin.length; _i5++) {
   defineSymbol(symbols_math, main, mathord, _ch5, _ch5);
   defineSymbol(symbols_text, main, symbols_textord, _ch5, _ch5);
 }
+
+defineSymbol(symbols_text, main, symbols_textord, "ð", "ð"); // Unicode versions of existing characters
+
+defineSymbol(symbols_text, main, symbols_textord, "\u2013", "–");
+defineSymbol(symbols_text, main, symbols_textord, "\u2014", "—");
+defineSymbol(symbols_text, main, symbols_textord, "\u2018", "‘");
+defineSymbol(symbols_text, main, symbols_textord, "\u2019", "’");
+defineSymbol(symbols_text, main, symbols_textord, "\u201C", "“");
+defineSymbol(symbols_text, main, symbols_textord, "\u201D", "”");
 // CONCATENATED MODULE: ./src/wide-character.js
 /**
  * This file provides support for Unicode range U+1D400 to U+1D7FF,
@@ -4826,8 +4884,8 @@ for (var _i5 = 0; _i5 < extraLatin.length; _i5++) {
 
 var wideLatinLetterData = [["mathbf", "textbf", "Main-Bold"], // A-Z bold upright
 ["mathbf", "textbf", "Main-Bold"], // a-z bold upright
-["mathnormal", "textit", "Math-Italic"], // A-Z italic
-["mathnormal", "textit", "Math-Italic"], // a-z italic
+["mathdefault", "textit", "Math-Italic"], // A-Z italic
+["mathdefault", "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.
@@ -5330,10 +5388,15 @@ var units_calculateSize = function calculateSize(sizeValue, options) {
 
 
 
+// The following have to be loaded from Main-Italic font, using class mathit
+var 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
  */
+
 var buildCommon_lookupSymbol = function lookupSymbol(value, // TODO(#963): Use a union type for this.
 fontName, mode) {
   // Replace the value with its replaced value from symbol.js
@@ -5420,6 +5483,54 @@ var buildCommon_mathsym = function mathsym(value, mode, options, classes) {
     return buildCommon_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.
+ */
+
+
+var buildCommon_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".
+ */
+
+
+var buildCommon_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",
@@ -5428,8 +5539,8 @@ var buildCommon_mathsym = function mathsym(value, mode, options, classes) {
  */
 
 
-var boldsymbol = function boldsymbol(value, mode, options, classes, type) {
-  if (type !== "textord" && buildCommon_lookupSymbol(value, "Math-BoldItalic", mode).metrics) {
+var boldsymbol = function boldsymbol(value, mode, options, classes) {
+  if (buildCommon_lookupSymbol(value, "Math-BoldItalic", mode).metrics) {
     return {
       fontName: "Math-BoldItalic",
       fontClass: "boldsymbol"
@@ -5467,10 +5578,13 @@ var buildCommon_makeOrd = function makeOrd(group, options, type) {
     var fontName;
     var fontClasses;
 
-    if (fontOrFamily === "boldsymbol") {
-      var fontData = boldsymbol(text, mode, options, classes, type);
+    if (fontOrFamily === "boldsymbol" || fontOrFamily === "mathnormal") {
+      var fontData = fontOrFamily === "boldsymbol" ? boldsymbol(text, mode, options, classes) : buildCommon_mathnormal(text, mode, options, classes);
       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];
@@ -5495,7 +5609,8 @@ var buildCommon_makeOrd = function makeOrd(group, options, type) {
 
 
   if (type === "mathord") {
-    return buildCommon_makeSymbol(text, "Math-Italic", mode, options, classes.concat(["mathnormal"]));
+    var fontLookup = buildCommon_mathdefault(text, mode, options, classes);
+    return buildCommon_makeSymbol(text, fontLookup.fontName, mode, options, classes.concat([fontLookup.fontClass]));
   } else if (type === "textord") {
     var font = src_symbols[mode][text] && src_symbols[mode][text].font;
 
@@ -5913,13 +6028,12 @@ var fontMap = {
     variant: "italic",
     fontName: "Main-Italic"
   },
-  "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.
+  // 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.
   // families
   "mathbb": {
     variant: "double-struck",
@@ -5954,9 +6068,7 @@ var svgData = {
   // oval to overlay the integrand
   oiintSize2: ["oiintSize2", 1.472, 0.659],
   oiiintSize1: ["oiiintSize1", 1.304, 0.499],
-  oiiintSize2: ["oiiintSize2", 1.98, 0.659],
-  leftParenInner: ["leftParenInner", 0.875, 0.3],
-  rightParenInner: ["rightParenInner", 0.875, 0.3]
+  oiiintSize2: ["oiiintSize2", 1.98, 0.659]
 };
 
 var buildCommon_staticSvg = function staticSvg(value, options) {
@@ -5998,6 +6110,88 @@ var buildCommon_staticSvg = function staticSvg(value, options) {
   svgData: svgData,
   tryCombineChars: buildCommon_tryCombineChars
 });
+// CONCATENATED MODULE: ./src/parseNode.js
+
+
+/**
+ * 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) {
+  var 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) {
+  var 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) {
+  var 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;
+}
 // CONCATENATED MODULE: ./src/spacingData.js
 /**
  * Describes spaces between different classes of atoms.
@@ -6092,20 +6286,7 @@ var tightSpacings = {
   }
 };
 // CONCATENATED MODULE: ./src/defineFunction.js
-/** 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.
@@ -6184,8 +6365,9 @@ function defineFunctionBuilders(_ref2) {
 } // Since the corresponding buildHTML/buildMathML function expects a
 // list of elements, we normalize for different kinds of arguments
 
-var ordargument = function ordargument(arg) {
-  return arg.type === "ordgroup" ? arg.body : [arg];
+var defineFunction_ordargument = function ordargument(arg) {
+  var node = checkNodeType(arg, "ordgroup");
+  return node ? node.body : [arg];
 };
 // CONCATENATED MODULE: ./src/buildHTML.js
 /**
@@ -6202,6 +6384,7 @@ var ordargument = function ordargument(arg) {
 
 
 
+
 var buildHTML_makeSpan = buildCommon.makeSpan; // Binary atoms (first class `mbin`) change into ordinary atoms (`mord`)
 // depending on their surroundings. See TeXbook pg. 442-446, Rules 5 and 6,
 // and the text before Rule 19.
@@ -6261,9 +6444,10 @@ var buildHTML_buildExpression = function buildExpression(expression, options, is
   var glueOptions = options;
 
   if (expression.length === 1) {
-    var node = expression[0];
+    var node = checkNodeType(expression[0], "sizing") || checkNodeType(expression[0], "styling");
 
-    if (node.type === "sizing") {
+    if (!node) {// No match.
+    } else if (node.type === "sizing") {
       glueOptions = options.havingSize(node.size);
     } else if (node.type === "styling") {
       glueOptions = options.havingStyle(styleMap[node.style]);
@@ -6280,7 +6464,6 @@ var buildHTML_buildExpression = function buildExpression(expression, options, is
   // Before determining what spaces to insert, perform bin cancellation.
   // Binary operators change to ordinary symbols in some contexts.
 
-  var isRoot = isRealGroup === "root";
   traverseNonSpaceNodes(groups, function (node, prev) {
     var prevType = prev.classes[0];
     var type = node.classes[0];
@@ -6292,7 +6475,7 @@ var buildHTML_buildExpression = function buildExpression(expression, options, is
     }
   }, {
     node: dummyPrev
-  }, dummyNext, isRoot);
+  }, dummyNext);
   traverseNonSpaceNodes(groups, function (node, prev) {
     var prevType = getTypeOfDomTree(prev);
     var type = getTypeOfDomTree(node); // 'mtight' indicates that the node is script or scriptscript style.
@@ -6305,7 +6488,7 @@ var buildHTML_buildExpression = function buildExpression(expression, options, is
     }
   }, {
     node: dummyPrev
-  }, dummyNext, isRoot);
+  }, dummyNext);
   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
@@ -6313,7 +6496,7 @@ var buildHTML_buildExpression = function buildExpression(expression, options, is
 // function to insert after it. `next` is a node that will be added to the right.
 // Used for bin cancellation and inserting spacings.
 
-var traverseNonSpaceNodes = function traverseNonSpaceNodes(nodes, callback, prev, next, isRoot) {
+var traverseNonSpaceNodes = function traverseNonSpaceNodes(nodes, callback, prev, next) {
   if (next) {
     // temporarily append the right node, if exists
     nodes.push(next);
@@ -6328,33 +6511,29 @@ var traverseNonSpaceNodes = function traverseNonSpaceNodes(nodes, callback, prev
     if (partialGroup) {
       // Recursive DFS
       // $FlowFixMe: make nodes a $ReadOnlyArray by returning a new array
-      traverseNonSpaceNodes(partialGroup.children, callback, prev, null, isRoot);
+      traverseNonSpaceNodes(partialGroup.children, callback, prev);
       continue;
     } // Ignore explicit spaces (e.g., \;, \,) when determining what implicit
     // spacing should go between atoms of different classes
 
 
-    var nonspace = !node.hasClass("mspace");
+    if (node.classes[0] === "mspace") {
+      continue;
+    }
 
-    if (nonspace) {
-      var result = callback(node, prev.node);
+    var 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++;
       }
     }
 
-    if (nonspace) {
-      prev.node = node;
-    } else if (isRoot && node.hasClass("newline")) {
-      prev.node = buildHTML_makeSpan(["leftmost"]); // treat like beginning of line
-    }
+    prev.node = node;
 
     prev.insertAfter = function (index) {
       return function (n) {
@@ -6371,7 +6550,7 @@ var traverseNonSpaceNodes = function traverseNonSpaceNodes(nodes, callback, prev
 
 
 var buildHTML_checkPartialGroup = function checkPartialGroup(node) {
-  if (node instanceof tree_DocumentFragment || node instanceof domTree_Anchor || node instanceof domTree_Span && node.hasClass("enclosing")) {
+  if (node instanceof tree_DocumentFragment || node instanceof domTree_Anchor) {
     return node;
   }
 
@@ -6456,6 +6635,10 @@ function buildHTMLUnbreakable(children, options) {
   var body = buildHTML_makeSpan(["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.
 
   var strut = buildHTML_makeSpan(["strut"]);
   strut.style.height = body.height + body.depth + "em";
@@ -6479,7 +6662,7 @@ function buildHTML(tree, options) {
   } // Build the expression contained in the tree
 
 
-  var expression = buildHTML_buildExpression(tree, options, "root");
+  var expression = buildHTML_buildExpression(tree, options, true);
   var 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
@@ -6867,7 +7050,7 @@ var buildMathML_getVariant = function getVariant(group, options) {
   if (font === "mathit") {
     return "italic";
   } else if (font === "boldsymbol") {
-    return group.type === "textord" ? "bold" : "bold-italic";
+    return "bold-italic";
   } else if (font === "mathbf") {
     return "bold";
   } else if (font === "mathbb") {
@@ -7007,7 +7190,7 @@ var buildMathML_buildGroup = function buildGroup(group, options) {
  * we can do appropriate styling.
  */
 
-function buildMathML(tree, texExpression, options, isDisplayMode, forMathmlOnly) {
+function buildMathML(tree, texExpression, options, forMathmlOnly) {
   var expression = buildMathML_buildExpression(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>.
 
@@ -7024,16 +7207,11 @@ function buildMathML(tree, texExpression, options, isDisplayMode, forMathmlOnly)
   annotation.setAttribute("encoding", "application/x-tex");
   var semantics = new mathMLTree.MathNode("semantics", [wrapper, annotation]);
   var math = new mathMLTree.MathNode("math", [semantics]);
-  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.
+  math.setAttribute("xmlns", "http://www.w3.org/1998/Math/MathML"); // 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.
 
-
   var wrapperClass = forMathmlOnly ? "katex" : "katex-mathml"; // $FlowFixMe
 
   return buildCommon.makeSpan([wrapperClass], [math]);
@@ -7077,12 +7255,12 @@ var buildTree_buildTree = function buildTree(tree, expression, settings) {
   var katexNode;
 
   if (settings.output === "mathml") {
-    return buildMathML(tree, expression, options, settings.displayMode, true);
+    return buildMathML(tree, expression, options, true);
   } else if (settings.output === "html") {
     var htmlNode = buildHTML(tree, options);
     katexNode = buildCommon.makeSpan(["katex"], [htmlNode]);
   } else {
-    var mathMLNode = buildMathML(tree, expression, options, settings.displayMode, false);
+    var mathMLNode = buildMathML(tree, expression, options, false);
 
     var _htmlNode = buildHTML(tree, options);
 
@@ -7442,47 +7620,6 @@ var stretchy_encloseSpan = function encloseSpan(inner, label, pad, options) {
   mathMLnode: stretchy_mathMLnode,
   svgSpan: stretchy_svgSpan
 });
-// CONCATENATED MODULE: ./src/parseNode.js
-
-
-/**
- * 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) {
-  var 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;
-}
 // CONCATENATED MODULE: ./src/functions/accent.js
 
 
@@ -7498,9 +7635,10 @@ var accent_htmlBuilder = function htmlBuilder(grp, options) {
   // Accents are handled in the TeXbook pg. 443, rule 12.
   var base;
   var group;
+  var supSub = checkNodeType(grp, "supsub");
   var supSubGroup;
 
-  if (grp && grp.type === "supsub") {
+  if (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
@@ -7509,16 +7647,16 @@ var accent_htmlBuilder = function 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(grp.base, "accent"); // The character box is the base of the accent group
+    group = assertNodeType(supSub.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
 
-    grp.base = base; // Rerender the supsub group with its new base, and store that
+    supSub.base = base; // Rerender the supsub group with its new base, and store that
     // result.
 
-    supSubGroup = assertSpan(buildHTML_buildGroup(grp, options)); // reset original base
+    supSubGroup = assertSpan(buildHTML_buildGroup(supSub, options)); // reset original base
 
-    grp.base = group;
+    supSub.base = group;
   } else {
     group = assertNodeType(grp, "accent");
     base = group.base;
@@ -7742,8 +7880,8 @@ defineFunction({
     var kern = group.label === "\\utilde" ? 0.12 : 0; // Generate the vlist, with the appropriate kerns
 
     var vlist = buildCommon.makeVList({
-      positionType: "top",
-      positionData: innerGroup.height,
+      positionType: "bottom",
+      positionData: accentBody.height + kern,
       children: [{
         type: "elem",
         elem: accentBody,
@@ -7979,7 +8117,7 @@ defineFunction({
       type: "color",
       mode: parser.mode,
       color: color,
-      body: ordargument(body)
+      body: defineFunction_ordargument(body)
     };
   },
   htmlBuilder: color_htmlBuilder,
@@ -8081,212 +8219,15 @@ defineFunction({
   mathmlBuilder: function mathmlBuilder(group, options) {
     var node = new mathMLTree.MathNode("mspace");
 
-    if (group.newLine) {
-      node.setAttribute("linebreak", "newline");
-
-      if (group.size) {
-        node.setAttribute("height", units_calculateSize(group.size, options) + "em");
-      }
-    }
-
-    return node;
-  }
-});
-// CONCATENATED MODULE: ./src/functions/def.js
-
-
-
-var globalMap = {
-  "\\global": "\\global",
-  "\\long": "\\\\globallong",
-  "\\\\globallong": "\\\\globallong",
-  "\\def": "\\gdef",
-  "\\gdef": "\\gdef",
-  "\\edef": "\\xdef",
-  "\\xdef": "\\xdef",
-  "\\let": "\\\\globallet",
-  "\\futurelet": "\\\\globalfuture"
-};
-
-var def_checkControlSequence = function checkControlSequence(tok) {
-  var name = tok.text;
-
-  if (/^(?:[\\{}$&#^_]|EOF)$/.test(name)) {
-    throw new src_ParseError("Expected a control sequence", tok);
-  }
-
-  return name;
-};
-
-var getRHS = function getRHS(parser) {
-  var 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;
-};
-
-var letCommand = function letCommand(parser, name, tok, global) {
-  var 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: function handler(_ref) {
-    var parser = _ref.parser,
-        funcName = _ref.funcName;
-    parser.consumeSpaces();
-    var 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 src_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
-  },
-  handler: function handler(_ref2) {
-    var parser = _ref2.parser,
-        funcName = _ref2.funcName;
-    var arg = parser.gullet.consumeArgs(1)[0];
-
-    if (arg.length !== 1) {
-      throw new src_ParseError("\\gdef's first argument must be a macro name");
-    }
-
-    var name = arg[0].text; // Count argument specifiers, and check they are in the order #1 #2 ...
-
-    var numArgs = 0;
-    arg = parser.gullet.consumeArgs(1)[0];
-
-    while (arg.length === 1 && arg[0].text === "#") {
-      arg = parser.gullet.consumeArgs(1)[0];
-
-      if (arg.length !== 1) {
-        throw new src_ParseError("Invalid argument number length \"" + arg.length + "\"");
-      }
-
-      if (!/^[1-9]$/.test(arg[0].text)) {
-        throw new src_ParseError("Invalid argument number \"" + arg[0].text + "\"");
-      }
-
-      numArgs++;
+    if (group.newLine) {
+      node.setAttribute("linebreak", "newline");
 
-      if (parseInt(arg[0].text) !== numArgs) {
-        throw new src_ParseError("Argument number \"" + arg[0].text + "\" out of order");
+      if (group.size) {
+        node.setAttribute("height", units_calculateSize(group.size, options) + "em");
       }
-
-      arg = parser.gullet.consumeArgs(1)[0];
     }
 
-    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: 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
-  },
-  handler: function handler(_ref3) {
-    var parser = _ref3.parser,
-        funcName = _ref3.funcName;
-    var name = def_checkControlSequence(parser.gullet.popToken());
-    parser.gullet.consumeSpaces();
-    var tok = getRHS(parser);
-    letCommand(parser, name, tok, funcName === "\\\\globallet");
-    return {
-      type: "internal",
-      mode: parser.mode
-    };
-  }
-}); // ref: https://www.tug.org/TUGboat/tb09-3/tb22bechtolsheim.pdf
-
-defineFunction({
-  type: "internal",
-  names: ["\\futurelet", "\\\\globalfuture"],
-  props: {
-    numArgs: 0,
-    allowedInText: true
-  },
-  handler: function handler(_ref4) {
-    var parser = _ref4.parser,
-        funcName = _ref4.funcName;
-    var name = def_checkControlSequence(parser.gullet.popToken());
-    var middle = parser.gullet.popToken();
-    var tok = parser.gullet.popToken();
-    letCommand(parser, name, tok, funcName === "\\\\globalfuture");
-    parser.gullet.pushToken(tok);
-    parser.gullet.pushToken(middle);
-    return {
-      type: "internal",
-      mode: parser.mode
-    };
+    return node;
   }
 });
 // CONCATENATED MODULE: ./src/delimiter.js
@@ -8617,33 +8558,12 @@ var delimiter_makeStackedDelim = function makeStackedDelim(delim, heightTotal, c
   // at a position that juts 0.005 above the bottom of the top element.
 
 
-  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.
-    var overlap = buildCommon.svgData.leftParenInner[2] / 2;
-    inners.push({
-      type: "kern",
-      size: -overlap
-    });
-    var pathName = repeat === "\u239C" ? "leftParenInner" : "rightParenInner";
-    var 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(delimiter_makeInner(repeat, font, mode));
-    inners.push(lap);
-  } // Add the top symbol
-
+  inners.push({
+    type: "kern",
+    size: shiftOfExtraElement
+  });
+  inners.push(delimiter_makeInner(repeat, font, mode));
+  inners.push(lap); // Add the top symbol
 
   inners.push(delimiter_makeInner(top, font, mode)); // Finally, build the vlist
 
@@ -9067,10 +8987,8 @@ function checkDelimiter(delim, context) {
 
   if (symDelim && utils.contains(delimiters, symDelim.text)) {
     return symDelim;
-  } else if (symDelim) {
-    throw new src_ParseError("Invalid delimiter '" + symDelim.text + "' after '" + context.funcName + "'", delim);
   } else {
-    throw new src_ParseError("Invalid delimiter type '" + delim.type + "'", delim);
+    throw new src_ParseError("Invalid delimiter: '" + (symDelim ? symDelim.text : JSON.stringify(delim)) + "' after '" + context.funcName + "'", delim);
   }
 }
 
@@ -10058,7 +9976,7 @@ var array_mathmlBuilder = function mathmlBuilder(group, options) {
   var menclose = "";
   var align = "";
 
-  if (group.cols && group.cols.length > 0) {
+  if (group.cols) {
     // Find column alignment, column spacing, and  vertical lines.
     var cols = group.cols;
     var columnLines = "";
@@ -10173,12 +10091,13 @@ var array_alignedHandler = function alignedHandler(context, args) {
     mode: context.mode,
     body: []
   };
+  var ordgroup = checkNodeType(args[0], "ordgroup");
 
-  if (args[0] && args[0].type === "ordgroup") {
+  if (ordgroup) {
     var arg0 = "";
 
-    for (var i = 0; i < args[0].body.length; i++) {
-      var textord = assertNodeType(args[0].body[i], "textord");
+    for (var i = 0; i < ordgroup.body.length; i++) {
+      var textord = assertNodeType(ordgroup.body[i], "textord");
       arg0 += textord.text;
     }
 
@@ -10191,8 +10110,10 @@ var array_alignedHandler = function alignedHandler(context, args) {
     for (var _i3 = 1; _i3 < row.length; _i3 += 2) {
       // Modify ordgroup node within styling node
       var styling = assertNodeType(row[_i3], "styling");
-      var ordgroup = assertNodeType(styling.body[0], "ordgroup");
-      ordgroup.body.unshift(emptyGroup);
+
+      var _ordgroup = assertNodeType(styling.body[0], "ordgroup");
+
+      _ordgroup.body.unshift(emptyGroup);
     }
 
     if (!isAligned) {
@@ -10370,7 +10291,7 @@ defineEnvironment({
     };
     res = parseArray(context.parser, res, "script");
 
-    if (res.body.length > 0 && res.body[0].length > 1) {
+    if (res.body[0].length > 1) {
       throw new src_ParseError("{subarray} can contain only one column");
     }
 
@@ -10383,11 +10304,10 @@ 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", "rcases", "drcases"],
+  names: ["cases", "dcases"],
   props: {
     numArgs: 0
   },
@@ -10417,8 +10337,8 @@ defineEnvironment({
       type: "leftright",
       mode: context.mode,
       body: [res],
-      left: context.envName.indexOf("r") > -1 ? "." : "\\{",
-      right: context.envName.indexOf("r") > -1 ? "\\}" : ".",
+      left: "\\{",
+      right: ".",
       rightColor: undefined
     };
   },
@@ -10637,7 +10557,7 @@ defineFunction({
       mode: parser.mode,
       mclass: "m" + funcName.substr(5),
       // TODO(kevinb): don't prefix with 'm'
-      body: ordargument(body),
+      body: defineFunction_ordargument(body),
       isCharacterBox: utils.isCharacterBox(body)
     };
   },
@@ -10705,7 +10625,7 @@ defineFunction({
       parentIsSupSub: false,
       symbol: false,
       suppressBaseShift: funcName !== "\\stackrel",
-      body: ordargument(baseArg)
+      body: defineFunction_ordargument(baseArg)
     };
     var supsub = {
       type: "supsub",
@@ -10811,7 +10731,7 @@ defineFunction({
 
 defineFunction({
   type: "font",
-  names: ["\\rm", "\\sf", "\\tt", "\\bf", "\\it", "\\cal"],
+  names: ["\\rm", "\\sf", "\\tt", "\\bf", "\\it"],
   props: {
     numArgs: 0,
     allowedInText: true
@@ -11224,8 +11144,20 @@ defineFunction({
     var numer = args[4];
     var denom = args[5]; // Look into the parse nodes to get the desired delimiters.
 
-    var leftDelim = args[0].type === "atom" && args[0].family === "open" ? delimFromValue(args[0].text) : null;
-    var rightDelim = args[1].type === "atom" && args[1].family === "close" ? delimFromValue(args[1].text) : null;
+    var leftNode = checkNodeType(args[0], "atom");
+
+    if (leftNode) {
+      leftNode = assertAtomFamily(args[0], "open");
+    }
+
+    var leftDelim = leftNode ? delimFromValue(leftNode.text) : null;
+    var rightNode = checkNodeType(args[1], "atom");
+
+    if (rightNode) {
+      rightNode = assertAtomFamily(args[1], "close");
+    }
+
+    var rightDelim = rightNode ? delimFromValue(rightNode.text) : null;
     var barNode = assertNodeType(args[2], "size");
     var hasBarLine;
     var barSize = null;
@@ -11242,15 +11174,15 @@ defineFunction({
 
 
     var size = "auto";
-    var styl = args[3];
+    var styl = checkNodeType(args[3], "ordgroup");
 
-    if (styl.type === "ordgroup") {
+    if (styl) {
       if (styl.body.length > 0) {
         var textOrd = assertNodeType(styl.body[0], "textord");
         size = stylArray[Number(textOrd.text)];
       }
     } else {
-      styl = assertNodeType(styl, "textord");
+      styl = assertNodeType(args[3], "textord");
       size = stylArray[Number(styl.text)];
     }
 
@@ -11337,13 +11269,14 @@ var horizBrace_htmlBuilder = function htmlBuilder(grp, options) {
 
   var supSubGroup;
   var group;
+  var supSub = checkNodeType(grp, "supsub");
 
-  if (grp.type === "supsub") {
+  if (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 = grp.sup ? buildHTML_buildGroup(grp.sup, options.havingStyle(style.sup()), options) : buildHTML_buildGroup(grp.sub, options.havingStyle(style.sub()), options);
-    group = assertNodeType(grp.base, "horizBrace");
+    supSubGroup = supSub.sup ? buildHTML_buildGroup(supSub.sup, options.havingStyle(style.sup()), options) : buildHTML_buildGroup(supSub.sub, options.havingStyle(style.sub()), options);
+    group = assertNodeType(supSub.base, "horizBrace");
   } else {
     group = assertNodeType(grp, "horizBrace");
   } // Build the base group
@@ -11493,7 +11426,7 @@ defineFunction({
       type: "href",
       mode: parser.mode,
       href: href,
-      body: ordargument(body)
+      body: defineFunction_ordargument(body)
     };
   },
   htmlBuilder: function htmlBuilder(group, options) {
@@ -11556,120 +11489,8 @@ defineFunction({
       type: "href",
       mode: parser.mode,
       href: href,
-      body: ordargument(body)
-    };
-  }
-});
-// CONCATENATED MODULE: ./src/functions/html.js
-
-
-
-
-
-
-defineFunction({
-  type: "html",
-  names: ["\\htmlClass", "\\htmlId", "\\htmlStyle", "\\htmlData"],
-  props: {
-    numArgs: 2,
-    argTypes: ["raw", "original"],
-    allowedInText: true
-  },
-  handler: function handler(_ref, args) {
-    var parser = _ref.parser,
-        funcName = _ref.funcName,
-        token = _ref.token;
-    var value = assertNodeType(args[0], "raw").string;
-    var body = args[1];
-
-    if (parser.settings.strict) {
-      parser.settings.reportNonstrict("htmlExtension", "HTML extension is disabled on strict mode");
-    }
-
-    var trustContext;
-    var 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":
-        {
-          var data = value.split(",");
-
-          for (var i = 0; i < data.length; i++) {
-            var keyVal = data[i].split("=");
-
-            if (keyVal.length !== 2) {
-              throw new src_ParseError("Error parsing key-value for \\htmlData");
-            }
-
-            attributes["data-" + keyVal[0].trim()] = keyVal[1].trim();
-          }
-
-          trustContext = {
-            command: "\\htmlData",
-            attributes: 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: attributes,
-      body: ordargument(body)
+      body: defineFunction_ordargument(body)
     };
-  },
-  htmlBuilder: function htmlBuilder(group, options) {
-    var elements = buildHTML_buildExpression(group.body, options, false);
-    var classes = ["enclosing"];
-
-    if (group.attributes.class) {
-      classes.push.apply(classes, group.attributes.class.trim().split(/\s+/));
-    }
-
-    var span = buildCommon.makeSpan(classes, elements, options);
-
-    for (var attr in group.attributes) {
-      if (attr !== "class" && group.attributes.hasOwnProperty(attr)) {
-        span.setAttribute(attr, group.attributes[attr]);
-      }
-    }
-
-    return span;
-  },
-  mathmlBuilder: function mathmlBuilder(group, options) {
-    return buildExpressionRow(group.body, options);
   }
 });
 // CONCATENATED MODULE: ./src/functions/htmlmathml.js
@@ -11689,8 +11510,8 @@ defineFunction({
     return {
       type: "htmlmathml",
       mode: parser.mode,
-      html: ordargument(args[0]),
-      mathml: ordargument(args[1])
+      html: defineFunction_ordargument(args[0]),
+      mathml: defineFunction_ordargument(args[1])
     };
   },
   htmlBuilder: function htmlBuilder(group, options) {
@@ -11979,16 +11800,21 @@ 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
 
     var 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.makeSpan(["thinbox"], [node], options);
-    return buildCommon.makeSpan(["mord", "vbox"], [node], options);
+    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);
   },
   mathmlBuilder: function mathmlBuilder(group, options) {
     // mathllap, mathrlap, mathclap
@@ -12083,10 +11909,10 @@ defineFunction({
     return {
       type: "mathchoice",
       mode: parser.mode,
-      display: ordargument(args[0]),
-      text: ordargument(args[1]),
-      script: ordargument(args[2]),
-      scriptscript: ordargument(args[3])
+      display: defineFunction_ordargument(args[0]),
+      text: defineFunction_ordargument(args[1]),
+      script: defineFunction_ordargument(args[2]),
+      scriptscript: defineFunction_ordargument(args[3])
     };
   },
   htmlBuilder: function htmlBuilder(group, options) {
@@ -12104,6 +11930,8 @@ defineFunction({
 
 // For an operator with limits, assemble the base, sup, and sub into a span.
 var assembleSupSub_assembleSupSub = function 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]);
   var sub;
   var sup; // We manually have to handle the superscripts and subscripts. This,
@@ -12236,14 +12064,15 @@ var op_htmlBuilder = function htmlBuilder(grp, options) {
   var subGroup;
   var hasLimits = false;
   var group;
+  var supSub = checkNodeType(grp, "supsub");
 
-  if (grp.type === "supsub") {
+  if (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 = grp.sup;
-    subGroup = grp.sub;
-    group = assertNodeType(grp.base, "op");
+    supGroup = supSub.sup;
+    subGroup = supSub.sub;
+    group = assertNodeType(supSub.base, "op");
     hasLimits = true;
   } else {
     group = assertNodeType(grp, "op");
@@ -12439,7 +12268,7 @@ defineFunction({
       limits: false,
       parentIsSupSub: false,
       symbol: false,
-      body: ordargument(body)
+      body: defineFunction_ordargument(body)
     };
   },
   htmlBuilder: op_htmlBuilder,
@@ -12545,14 +12374,15 @@ var operatorname_htmlBuilder = function htmlBuilder(grp, options) {
   var subGroup;
   var hasLimits = false;
   var group;
+  var supSub = checkNodeType(grp, "supsub");
 
-  if (grp.type === "supsub") {
+  if (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 = grp.sup;
-    subGroup = grp.sub;
-    group = assertNodeType(grp.base, "operatorname");
+    supGroup = supSub.sup;
+    subGroup = supSub.sub;
+    group = assertNodeType(supSub.base, "operatorname");
     hasLimits = true;
   } else {
     group = assertNodeType(grp, "operatorname");
@@ -12677,7 +12507,7 @@ defineFunction({
     return {
       type: "operatorname",
       mode: parser.mode,
-      body: ordargument(body),
+      body: defineFunction_ordargument(body),
       alwaysHandleSupSub: funcName === "\\operatorname*",
       limits: false,
       parentIsSupSub: false
@@ -12778,7 +12608,7 @@ defineFunction({
     return {
       type: "phantom",
       mode: parser.mode,
-      body: ordargument(body)
+      body: defineFunction_ordargument(body)
     };
   },
   htmlBuilder: function htmlBuilder(group, options) {
@@ -12832,7 +12662,7 @@ defineFunction({
     return buildCommon.makeSpan(["mord"], [node], options);
   },
   mathmlBuilder: function mathmlBuilder(group, options) {
-    var inner = buildMathML_buildExpression(ordargument(group.body), options);
+    var inner = buildMathML_buildExpression(defineFunction_ordargument(group.body), options);
     var phantom = new mathMLTree.MathNode("mphantom", inner);
     var node = new mathMLTree.MathNode("mpadded", [phantom]);
     node.setAttribute("height", "0px");
@@ -12862,7 +12692,7 @@ defineFunction({
     return buildCommon.makeSpan(["mord", "rlap"], [inner, fix], options);
   },
   mathmlBuilder: function mathmlBuilder(group, options) {
-    var inner = buildMathML_buildExpression(ordargument(group.body), options);
+    var inner = buildMathML_buildExpression(defineFunction_ordargument(group.body), options);
     var phantom = new mathMLTree.MathNode("mphantom", inner);
     var node = new mathMLTree.MathNode("mpadded", [phantom]);
     node.setAttribute("width", "0px");
@@ -13362,6 +13192,7 @@ defineFunction({
 
 
 
+
 /**
  * Sometimes, groups perform special rules when they have superscripts or
  * subscripts attached to them. This function lets the `supsub` group know that
@@ -13542,13 +13373,14 @@ defineFunctionBuilders({
     var isBrace = false;
     var isOver;
     var isSup;
+    var horizBrace = checkNodeType(group.base, "horizBrace");
 
-    if (group.base && group.base.type === "horizBrace") {
+    if (horizBrace) {
       isSup = !!group.sup;
 
-      if (isSup === group.base.isOver) {
+      if (isSup === horizBrace.isOver) {
         isBrace = true;
-        isOver = group.base.isOver;
+        isOver = horizBrace.isOver;
       }
     }
 
@@ -13838,7 +13670,7 @@ defineFunction({
     return {
       type: "text",
       mode: parser.mode,
-      body: ordargument(body),
+      body: defineFunction_ordargument(body),
       font: funcName
     };
   },
@@ -14005,8 +13837,6 @@ var functions = _functions;
 
 
 
-
-
 
 
 
@@ -14282,7 +14112,6 @@ function () {
 
 
 
-
 var builtinMacros = {};
 /* harmony default export */ var macros = (builtinMacros); // This function might one day accept an additional argument and do more things.
 
@@ -14290,37 +14119,7 @@ function defineMacro(name, body) {
   builtinMacros[name] = body;
 } //////////////////////////////////////////////////////////////////////
 // macro tools
-
-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.
-  var 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.
-  var 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
+// LaTeX's \@firstoftwo{#1}{#2} expands to #1, skipping #2
 // TeX source: \long\def\@firstoftwo#1#2{#1}
 
 defineMacro("\\@firstoftwo", function (context) {
@@ -14339,14 +14138,12 @@ defineMacro("\\@secondoftwo", function (context) {
     numArgs: 0
   };
 }); // LaTeX's \@ifnextchar{#1}{#2}{#3} looks ahead to the next (unexpanded)
-// 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.
+// 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.
 
 defineMacro("\\@ifnextchar", function (context) {
   var args = context.consumeArgs(3); // symbol, if, else
 
-  context.consumeSpaces();
   var nextToken = context.future();
 
   if (args[0].length === 1 && args[0][0].text === nextToken.text) {
@@ -14459,6 +14256,74 @@ 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
+
+var macros_def = function def(context, global) {
+  var arg = context.consumeArgs(1)[0];
+
+  if (arg.length !== 1) {
+    throw new src_ParseError("\\gdef's first argument must be a macro name");
+  }
+
+  var name = arg[0].text; // Count argument specifiers, and check they are in the order #1 #2 ...
+
+  var 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 src_ParseError("Invalid argument number length \"" + arg.length + "\"");
+    }
+
+    if (!/^[1-9]$/.test(arg[0].text)) {
+      throw new src_ParseError("Invalid argument number \"" + arg[0].text + "\"");
+    }
+
+    numArgs++;
+
+    if (parseInt(arg[0].text) !== numArgs) {
+      throw new src_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: numArgs
+  }, global);
+  return '';
+};
+
+defineMacro("\\gdef", function (context) {
+  return macros_def(context, true);
+});
+defineMacro("\\def", function (context) {
+  return macros_def(context, false);
+});
+defineMacro("\\global", function (context) {
+  var next = context.consumeArgs(1)[0];
+
+  if (next.length !== 1) {
+    throw new src_ParseError("Invalid command after \\global");
+  }
+
+  var command = next[0].text; // TODO: Should expand command
+
+  if (command === "\\def") {
+    // \global\def is equivalent to \gdef
+    return macros_def(context, true);
+  } else {
+    throw new src_ParseError("Invalid command '" + command + "' after \\global");
+  }
 }); // \newcommand{\macro}[args]{definition}
 // \renewcommand{\macro}[args]{definition}
 // TODO: Optional arguments: \newcommand{\macro}[args][default]{definition}
@@ -14518,30 +14383,6 @@ defineMacro("\\renewcommand", function (context) {
 });
 defineMacro("\\providecommand", function (context) {
   return macros_newcommand(context, true, true);
-}); // terminal (console) tools
-
-defineMacro("\\message", function (context) {
-  var arg = context.consumeArgs(1)[0]; // eslint-disable-next-line no-console
-
-  console.log(arg.reverse().map(function (token) {
-    return token.text;
-  }).join(""));
-  return '';
-});
-defineMacro("\\errmessage", function (context) {
-  var arg = context.consumeArgs(1)[0]; // eslint-disable-next-line no-console
-
-  console.error(arg.reverse().map(function (token) {
-    return token.text;
-  }).join(""));
-  return '';
-});
-defineMacro("\\show", function (context) {
-  var tok = context.popToken();
-  var name = tok.text; // eslint-disable-next-line no-console
-
-  console.log(tok, context.macros.get(name), src_functions[name], src_symbols.math[name], src_symbols.text[name]);
-  return '';
 }); //////////////////////////////////////////////////////////////////////
 // Grouping
 // \let\bgroup={ \let\egroup=}
@@ -14624,13 +14465,7 @@ defineMacro("\u231E", "\\llcorner");
 defineMacro("\u231F", "\\lrcorner");
 defineMacro("\xA9", "\\copyright");
 defineMacro("\xAE", "\\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}}"); //////////////////////////////////////////////////////////////////////
+defineMacro("\uFE0F", "\\textregistered"); //////////////////////////////////////////////////////////////////////
 // LaTeX_2ε
 // \vdots{\vbox{\baselineskip4\p@  \lineskiplimit\z@
 // \kern6\p@\hbox{.}\hbox{.}\hbox{.}}}
@@ -14999,9 +14834,7 @@ 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("\\imath", "\\html@mathml{\\@imath}{\u0131}");
-defineMacro("\\jmath", "\\html@mathml{\\@jmath}{\u0237}"); //////////////////////////////////////////////////////////////////////
+defineMacro("\\varsupsetneqq", "\\html@mathml{\\@varsupsetneqq}{⫌}"); //////////////////////////////////////////////////////////////////////
 // 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.
@@ -15019,11 +14852,7 @@ 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
@@ -15099,15 +14928,7 @@ defineMacro("\\Zeta", "\\mathrm{Z}"); //////////////////////////////////////////
 
 defineMacro("\\argmin", "\\DOTSB\\operatorname*{arg\\,min}");
 defineMacro("\\argmax", "\\DOTSB\\operatorname*{arg\\,max}");
-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("\\plim", "\\DOTSB\\mathop{\\operatorname{plim}}\\limits"); // Custom Khan Academy colors, should be moved to an optional package
 
 defineMacro("\\blue", "\\textcolor{##6495ed}{#1}");
 defineMacro("\\orange", "\\textcolor{##ffa500}{#1}");
@@ -15367,22 +15188,18 @@ function () {
    * 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.
    */
   ;
 
-  _proto.expandOnce = function expandOnce(expandableOnly) {
+  _proto.expandOnce = function expandOnce() {
     var topToken = this.popToken();
     var name = topToken.text;
-    var expansion = !topToken.noexpand ? this._getExpansion(name) : null;
 
-    if (expansion == null || expandableOnly && expansion.unexpandable) {
-      if (expandableOnly && expansion == null && name[0] === "\\" && !this.isDefined(name)) {
-        throw new src_ParseError("Undefined control sequence: " + name);
-      }
+    var expansion = this._getExpansion(name);
 
+    if (expansion == null) {
+      // mainly checking for undefined here
+      // Fully expanded
       this.pushToken(topToken);
       return topToken;
     }
@@ -15453,9 +15270,7 @@ function () {
       if (expanded instanceof Token_Token) {
         // \relax stops the expansion, but shouldn't get returned (a
         // null return value couldn't get implemented as a function).
-        // the token after \noexpand is interpreted as if its meaning
-        // were ‘\relax’
-        if (expanded.text === "\\relax" || expanded.treatAsRelax) {
+        if (expanded.text === "\\relax") {
           this.stack.pop();
         } else {
           return this.stack.pop(); // === expanded
@@ -15474,29 +15289,18 @@ function () {
   ;
 
   _proto.expandMacro = function expandMacro(name) {
-    return this.macros.has(name) ? this.expandTokens([new Token_Token(name)]) : undefined;
-  }
-  /**
-   * Fully expand the given token stream and return the resulting list of tokens
-   */
-  ;
+    if (!this.macros.get(name)) {
+      return undefined;
+    }
 
-  _proto.expandTokens = function expandTokens(tokens) {
     var output = [];
     var oldStackLength = this.stack.length;
-    this.pushTokens(tokens);
+    this.pushToken(new Token_Token(name));
 
     while (this.stack.length > oldStackLength) {
-      var expanded = this.expandOnce(true); // expand only expandable tokens
-      // expandOnce returns Token if and only if it's fully expanded.
+      var expanded = this.expandOnce(); // expandOnce returns Token if and only if it's fully expanded.
 
       if (expanded instanceof Token_Token) {
-        if (expanded.treatAsRelax) {
-          // the expansion of \noexpand is the token itself
-          expanded.noexpand = false;
-          expanded.treatAsRelax = false;
-        }
-
         output.push(this.stack.pop());
       }
     }
@@ -15577,24 +15381,700 @@ function () {
 
   _proto.isDefined = function isDefined(name) {
     return this.macros.has(name) || src_functions.hasOwnProperty(name) || src_symbols.math.hasOwnProperty(name) || src_symbols.text.hasOwnProperty(name) || implicitCommands.hasOwnProperty(name);
-  }
-  /**
-   * Determine whether a command is expandable.
-   */
-  ;
-
-  _proto.isExpandable = function isExpandable(name) {
-    var macro = this.macros.get(name);
-    return macro != null ? typeof macro === "string" || typeof macro === "function" || !macro.unexpandable // TODO(ylem): #2085
-    : src_functions.hasOwnProperty(name)
-    /* && !functions[name].primitive*/
-    ;
   };
 
   return MacroExpander;
 }();
 
 
+// CONCATENATED MODULE: ./src/unicodeAccents.js
+// Mapping of Unicode accent characters to their LaTeX equivalent in text and
+// math mode (when they exist).
+/* harmony default export */ var unicodeAccents = ({
+  "\u0301": {
+    text: "\\'",
+    math: '\\acute'
+  },
+  "\u0300": {
+    text: '\\`',
+    math: '\\grave'
+  },
+  "\u0308": {
+    text: '\\"',
+    math: '\\ddot'
+  },
+  "\u0303": {
+    text: '\\~',
+    math: '\\tilde'
+  },
+  "\u0304": {
+    text: '\\=',
+    math: '\\bar'
+  },
+  "\u0306": {
+    text: "\\u",
+    math: '\\breve'
+  },
+  "\u030C": {
+    text: '\\v',
+    math: '\\check'
+  },
+  "\u0302": {
+    text: '\\^',
+    math: '\\hat'
+  },
+  "\u0307": {
+    text: '\\.',
+    math: '\\dot'
+  },
+  "\u030A": {
+    text: '\\r',
+    math: '\\mathring'
+  },
+  "\u030B": {
+    text: '\\H'
+  }
+});
+// CONCATENATED MODULE: ./src/unicodeSymbols.js
+// This file is GENERATED by unicodeMake.js. DO NOT MODIFY.
+/* harmony default export */ var unicodeSymbols = ({
+  "\xE1": "a\u0301",
+  // á = \'{a}
+  "\xE0": "a\u0300",
+  // à = \`{a}
+  "\xE4": "a\u0308",
+  // ä = \"{a}
+  "\u01DF": "a\u0308\u0304",
+  // ǟ = \"\={a}
+  "\xE3": "a\u0303",
+  // ã = \~{a}
+  "\u0101": "a\u0304",
+  // ā = \={a}
+  "\u0103": "a\u0306",
+  // ă = \u{a}
+  "\u1EAF": "a\u0306\u0301",
+  // ắ = \u\'{a}
+  "\u1EB1": "a\u0306\u0300",
+  // ằ = \u\`{a}
+  "\u1EB5": "a\u0306\u0303",
+  // ẵ = \u\~{a}
+  "\u01CE": "a\u030C",
+  // ǎ = \v{a}
+  "\xE2": "a\u0302",
+  // â = \^{a}
+  "\u1EA5": "a\u0302\u0301",
+  // ấ = \^\'{a}
+  "\u1EA7": "a\u0302\u0300",
+  // ầ = \^\`{a}
+  "\u1EAB": "a\u0302\u0303",
+  // ẫ = \^\~{a}
+  "\u0227": "a\u0307",
+  // ȧ = \.{a}
+  "\u01E1": "a\u0307\u0304",
+  // ǡ = \.\={a}
+  "\xE5": "a\u030A",
+  // å = \r{a}
+  "\u01FB": "a\u030A\u0301",
+  // ǻ = \r\'{a}
+  "\u1E03": "b\u0307",
+  // ḃ = \.{b}
+  "\u0107": "c\u0301",
+  // ć = \'{c}
+  "\u010D": "c\u030C",
+  // č = \v{c}
+  "\u0109": "c\u0302",
+  // ĉ = \^{c}
+  "\u010B": "c\u0307",
+  // ċ = \.{c}
+  "\u010F": "d\u030C",
+  // ď = \v{d}
+  "\u1E0B": "d\u0307",
+  // ḋ = \.{d}
+  "\xE9": "e\u0301",
+  // é = \'{e}
+  "\xE8": "e\u0300",
+  // è = \`{e}
+  "\xEB": "e\u0308",
+  // ë = \"{e}
+  "\u1EBD": "e\u0303",
+  // ẽ = \~{e}
+  "\u0113": "e\u0304",
+  // ē = \={e}
+  "\u1E17": "e\u0304\u0301",
+  // ḗ = \=\'{e}
+  "\u1E15": "e\u0304\u0300",
+  // ḕ = \=\`{e}
+  "\u0115": "e\u0306",
+  // ĕ = \u{e}
+  "\u011B": "e\u030C",
+  // ě = \v{e}
+  "\xEA": "e\u0302",
+  // ê = \^{e}
+  "\u1EBF": "e\u0302\u0301",
+  // ế = \^\'{e}
+  "\u1EC1": "e\u0302\u0300",
+  // ề = \^\`{e}
+  "\u1EC5": "e\u0302\u0303",
+  // ễ = \^\~{e}
+  "\u0117": "e\u0307",
+  // ė = \.{e}
+  "\u1E1F": "f\u0307",
+  // ḟ = \.{f}
+  "\u01F5": "g\u0301",
+  // ǵ = \'{g}
+  "\u1E21": "g\u0304",
+  // ḡ = \={g}
+  "\u011F": "g\u0306",
+  // ğ = \u{g}
+  "\u01E7": "g\u030C",
+  // ǧ = \v{g}
+  "\u011D": "g\u0302",
+  // ĝ = \^{g}
+  "\u0121": "g\u0307",
+  // ġ = \.{g}
+  "\u1E27": "h\u0308",
+  // ḧ = \"{h}
+  "\u021F": "h\u030C",
+  // ȟ = \v{h}
+  "\u0125": "h\u0302",
+  // ĥ = \^{h}
+  "\u1E23": "h\u0307",
+  // ḣ = \.{h}
+  "\xED": "i\u0301",
+  // í = \'{i}
+  "\xEC": "i\u0300",
+  // ì = \`{i}
+  "\xEF": "i\u0308",
+  // ï = \"{i}
+  "\u1E2F": "i\u0308\u0301",
+  // ḯ = \"\'{i}
+  "\u0129": "i\u0303",
+  // ĩ = \~{i}
+  "\u012B": "i\u0304",
+  // ī = \={i}
+  "\u012D": "i\u0306",
+  // ĭ = \u{i}
+  "\u01D0": "i\u030C",
+  // ǐ = \v{i}
+  "\xEE": "i\u0302",
+  // î = \^{i}
+  "\u01F0": "j\u030C",
+  // ǰ = \v{j}
+  "\u0135": "j\u0302",
+  // ĵ = \^{j}
+  "\u1E31": "k\u0301",
+  // ḱ = \'{k}
+  "\u01E9": "k\u030C",
+  // ǩ = \v{k}
+  "\u013A": "l\u0301",
+  // ĺ = \'{l}
+  "\u013E": "l\u030C",
+  // ľ = \v{l}
+  "\u1E3F": "m\u0301",
+  // ḿ = \'{m}
+  "\u1E41": "m\u0307",
+  // ṁ = \.{m}
+  "\u0144": "n\u0301",
+  // ń = \'{n}
+  "\u01F9": "n\u0300",
+  // ǹ = \`{n}
+  "\xF1": "n\u0303",
+  // ñ = \~{n}
+  "\u0148": "n\u030C",
+  // ň = \v{n}
+  "\u1E45": "n\u0307",
+  // ṅ = \.{n}
+  "\xF3": "o\u0301",
+  // ó = \'{o}
+  "\xF2": "o\u0300",
+  // ò = \`{o}
+  "\xF6": "o\u0308",
+  // ö = \"{o}
+  "\u022B": "o\u0308\u0304",
+  // ȫ = \"\={o}
+  "\xF5": "o\u0303",
+  // õ = \~{o}
+  "\u1E4D": "o\u0303\u0301",
+  // ṍ = \~\'{o}
+  "\u1E4F": "o\u0303\u0308",
+  // ṏ = \~\"{o}
+  "\u022D": "o\u0303\u0304",
+  // ȭ = \~\={o}
+  "\u014D": "o\u0304",
+  // ō = \={o}
+  "\u1E53": "o\u0304\u0301",
+  // ṓ = \=\'{o}
+  "\u1E51": "o\u0304\u0300",
+  // ṑ = \=\`{o}
+  "\u014F": "o\u0306",
+  // ŏ = \u{o}
+  "\u01D2": "o\u030C",
+  // ǒ = \v{o}
+  "\xF4": "o\u0302",
+  // ô = \^{o}
+  "\u1ED1": "o\u0302\u0301",
+  // ố = \^\'{o}
+  "\u1ED3": "o\u0302\u0300",
+  // ồ = \^\`{o}
+  "\u1ED7": "o\u0302\u0303",
+  // ỗ = \^\~{o}
+  "\u022F": "o\u0307",
+  // ȯ = \.{o}
+  "\u0231": "o\u0307\u0304",
+  // ȱ = \.\={o}
+  "\u0151": "o\u030B",
+  // ő = \H{o}
+  "\u1E55": "p\u0301",
+  // ṕ = \'{p}
+  "\u1E57": "p\u0307",
+  // ṗ = \.{p}
+  "\u0155": "r\u0301",
+  // ŕ = \'{r}
+  "\u0159": "r\u030C",
+  // ř = \v{r}
+  "\u1E59": "r\u0307",
+  // ṙ = \.{r}
+  "\u015B": "s\u0301",
+  // ś = \'{s}
+  "\u1E65": "s\u0301\u0307",
+  // ṥ = \'\.{s}
+  "\u0161": "s\u030C",
+  // š = \v{s}
+  "\u1E67": "s\u030C\u0307",
+  // ṧ = \v\.{s}
+  "\u015D": "s\u0302",
+  // ŝ = \^{s}
+  "\u1E61": "s\u0307",
+  // ṡ = \.{s}
+  "\u1E97": "t\u0308",
+  // ẗ = \"{t}
+  "\u0165": "t\u030C",
+  // ť = \v{t}
+  "\u1E6B": "t\u0307",
+  // ṫ = \.{t}
+  "\xFA": "u\u0301",
+  // ú = \'{u}
+  "\xF9": "u\u0300",
+  // ù = \`{u}
+  "\xFC": "u\u0308",
+  // ü = \"{u}
+  "\u01D8": "u\u0308\u0301",
+  // ǘ = \"\'{u}
+  "\u01DC": "u\u0308\u0300",
+  // ǜ = \"\`{u}
+  "\u01D6": "u\u0308\u0304",
+  // ǖ = \"\={u}
+  "\u01DA": "u\u0308\u030C",
+  // ǚ = \"\v{u}
+  "\u0169": "u\u0303",
+  // ũ = \~{u}
+  "\u1E79": "u\u0303\u0301",
+  // ṹ = \~\'{u}
+  "\u016B": "u\u0304",
+  // ū = \={u}
+  "\u1E7B": "u\u0304\u0308",
+  // ṻ = \=\"{u}
+  "\u016D": "u\u0306",
+  // ŭ = \u{u}
+  "\u01D4": "u\u030C",
+  // ǔ = \v{u}
+  "\xFB": "u\u0302",
+  // û = \^{u}
+  "\u016F": "u\u030A",
+  // ů = \r{u}
+  "\u0171": "u\u030B",
+  // ű = \H{u}
+  "\u1E7D": "v\u0303",
+  // ṽ = \~{v}
+  "\u1E83": "w\u0301",
+  // ẃ = \'{w}
+  "\u1E81": "w\u0300",
+  // ẁ = \`{w}
+  "\u1E85": "w\u0308",
+  // ẅ = \"{w}
+  "\u0175": "w\u0302",
+  // ŵ = \^{w}
+  "\u1E87": "w\u0307",
+  // ẇ = \.{w}
+  "\u1E98": "w\u030A",
+  // ẘ = \r{w}
+  "\u1E8D": "x\u0308",
+  // ẍ = \"{x}
+  "\u1E8B": "x\u0307",
+  // ẋ = \.{x}
+  "\xFD": "y\u0301",
+  // ý = \'{y}
+  "\u1EF3": "y\u0300",
+  // ỳ = \`{y}
+  "\xFF": "y\u0308",
+  // ÿ = \"{y}
+  "\u1EF9": "y\u0303",
+  // ỹ = \~{y}
+  "\u0233": "y\u0304",
+  // ȳ = \={y}
+  "\u0177": "y\u0302",
+  // ŷ = \^{y}
+  "\u1E8F": "y\u0307",
+  // ẏ = \.{y}
+  "\u1E99": "y\u030A",
+  // ẙ = \r{y}
+  "\u017A": "z\u0301",
+  // ź = \'{z}
+  "\u017E": "z\u030C",
+  // ž = \v{z}
+  "\u1E91": "z\u0302",
+  // ẑ = \^{z}
+  "\u017C": "z\u0307",
+  // ż = \.{z}
+  "\xC1": "A\u0301",
+  // Á = \'{A}
+  "\xC0": "A\u0300",
+  // À = \`{A}
+  "\xC4": "A\u0308",
+  // Ä = \"{A}
+  "\u01DE": "A\u0308\u0304",
+  // Ǟ = \"\={A}
+  "\xC3": "A\u0303",
+  // Ã = \~{A}
+  "\u0100": "A\u0304",
+  // Ā = \={A}
+  "\u0102": "A\u0306",
+  // Ă = \u{A}
+  "\u1EAE": "A\u0306\u0301",
+  // Ắ = \u\'{A}
+  "\u1EB0": "A\u0306\u0300",
+  // Ằ = \u\`{A}
+  "\u1EB4": "A\u0306\u0303",
+  // Ẵ = \u\~{A}
+  "\u01CD": "A\u030C",
+  // Ǎ = \v{A}
+  "\xC2": "A\u0302",
+  // Â = \^{A}
+  "\u1EA4": "A\u0302\u0301",
+  // Ấ = \^\'{A}
+  "\u1EA6": "A\u0302\u0300",
+  // Ầ = \^\`{A}
+  "\u1EAA": "A\u0302\u0303",
+  // Ẫ = \^\~{A}
+  "\u0226": "A\u0307",
+  // Ȧ = \.{A}
+  "\u01E0": "A\u0307\u0304",
+  // Ǡ = \.\={A}
+  "\xC5": "A\u030A",
+  // Å = \r{A}
+  "\u01FA": "A\u030A\u0301",
+  // Ǻ = \r\'{A}
+  "\u1E02": "B\u0307",
+  // Ḃ = \.{B}
+  "\u0106": "C\u0301",
+  // Ć = \'{C}
+  "\u010C": "C\u030C",
+  // Č = \v{C}
+  "\u0108": "C\u0302",
+  // Ĉ = \^{C}
+  "\u010A": "C\u0307",
+  // Ċ = \.{C}
+  "\u010E": "D\u030C",
+  // Ď = \v{D}
+  "\u1E0A": "D\u0307",
+  // Ḋ = \.{D}
+  "\xC9": "E\u0301",
+  // É = \'{E}
+  "\xC8": "E\u0300",
+  // È = \`{E}
+  "\xCB": "E\u0308",
+  // Ë = \"{E}
+  "\u1EBC": "E\u0303",
+  // Ẽ = \~{E}
+  "\u0112": "E\u0304",
+  // Ē = \={E}
+  "\u1E16": "E\u0304\u0301",
+  // Ḗ = \=\'{E}
+  "\u1E14": "E\u0304\u0300",
+  // Ḕ = \=\`{E}
+  "\u0114": "E\u0306",
+  // Ĕ = \u{E}
+  "\u011A": "E\u030C",
+  // Ě = \v{E}
+  "\xCA": "E\u0302",
+  // Ê = \^{E}
+  "\u1EBE": "E\u0302\u0301",
+  // Ế = \^\'{E}
+  "\u1EC0": "E\u0302\u0300",
+  // Ề = \^\`{E}
+  "\u1EC4": "E\u0302\u0303",
+  // Ễ = \^\~{E}
+  "\u0116": "E\u0307",
+  // Ė = \.{E}
+  "\u1E1E": "F\u0307",
+  // Ḟ = \.{F}
+  "\u01F4": "G\u0301",
+  // Ǵ = \'{G}
+  "\u1E20": "G\u0304",
+  // Ḡ = \={G}
+  "\u011E": "G\u0306",
+  // Ğ = \u{G}
+  "\u01E6": "G\u030C",
+  // Ǧ = \v{G}
+  "\u011C": "G\u0302",
+  // Ĝ = \^{G}
+  "\u0120": "G\u0307",
+  // Ġ = \.{G}
+  "\u1E26": "H\u0308",
+  // Ḧ = \"{H}
+  "\u021E": "H\u030C",
+  // Ȟ = \v{H}
+  "\u0124": "H\u0302",
+  // Ĥ = \^{H}
+  "\u1E22": "H\u0307",
+  // Ḣ = \.{H}
+  "\xCD": "I\u0301",
+  // Í = \'{I}
+  "\xCC": "I\u0300",
+  // Ì = \`{I}
+  "\xCF": "I\u0308",
+  // Ï = \"{I}
+  "\u1E2E": "I\u0308\u0301",
+  // Ḯ = \"\'{I}
+  "\u0128": "I\u0303",
+  // Ĩ = \~{I}
+  "\u012A": "I\u0304",
+  // Ī = \={I}
+  "\u012C": "I\u0306",
+  // Ĭ = \u{I}
+  "\u01CF": "I\u030C",
+  // Ǐ = \v{I}
+  "\xCE": "I\u0302",
+  // Î = \^{I}
+  "\u0130": "I\u0307",
+  // İ = \.{I}
+  "\u0134": "J\u0302",
+  // Ĵ = \^{J}
+  "\u1E30": "K\u0301",
+  // Ḱ = \'{K}
+  "\u01E8": "K\u030C",
+  // Ǩ = \v{K}
+  "\u0139": "L\u0301",
+  // Ĺ = \'{L}
+  "\u013D": "L\u030C",
+  // Ľ = \v{L}
+  "\u1E3E": "M\u0301",
+  // Ḿ = \'{M}
+  "\u1E40": "M\u0307",
+  // Ṁ = \.{M}
+  "\u0143": "N\u0301",
+  // Ń = \'{N}
+  "\u01F8": "N\u0300",
+  // Ǹ = \`{N}
+  "\xD1": "N\u0303",
+  // Ñ = \~{N}
+  "\u0147": "N\u030C",
+  // Ň = \v{N}
+  "\u1E44": "N\u0307",
+  // Ṅ = \.{N}
+  "\xD3": "O\u0301",
+  // Ó = \'{O}
+  "\xD2": "O\u0300",
+  // Ò = \`{O}
+  "\xD6": "O\u0308",
+  // Ö = \"{O}
+  "\u022A": "O\u0308\u0304",
+  // Ȫ = \"\={O}
+  "\xD5": "O\u0303",
+  // Õ = \~{O}
+  "\u1E4C": "O\u0303\u0301",
+  // Ṍ = \~\'{O}
+  "\u1E4E": "O\u0303\u0308",
+  // Ṏ = \~\"{O}
+  "\u022C": "O\u0303\u0304",
+  // Ȭ = \~\={O}
+  "\u014C": "O\u0304",
+  // Ō = \={O}
+  "\u1E52": "O\u0304\u0301",
+  // Ṓ = \=\'{O}
+  "\u1E50": "O\u0304\u0300",
+  // Ṑ = \=\`{O}
+  "\u014E": "O\u0306",
+  // Ŏ = \u{O}
+  "\u01D1": "O\u030C",
+  // Ǒ = \v{O}
+  "\xD4": "O\u0302",
+  // Ô = \^{O}
+  "\u1ED0": "O\u0302\u0301",
+  // Ố = \^\'{O}
+  "\u1ED2": "O\u0302\u0300",
+  // Ồ = \^\`{O}
+  "\u1ED6": "O\u0302\u0303",
+  // Ỗ = \^\~{O}
+  "\u022E": "O\u0307",
+  // Ȯ = \.{O}
+  "\u0230": "O\u0307\u0304",
+  // Ȱ = \.\={O}
+  "\u0150": "O\u030B",
+  // Ő = \H{O}
+  "\u1E54": "P\u0301",
+  // Ṕ = \'{P}
+  "\u1E56": "P\u0307",
+  // Ṗ = \.{P}
+  "\u0154": "R\u0301",
+  // Ŕ = \'{R}
+  "\u0158": "R\u030C",
+  // Ř = \v{R}
+  "\u1E58": "R\u0307",
+  // Ṙ = \.{R}
+  "\u015A": "S\u0301",
+  // Ś = \'{S}
+  "\u1E64": "S\u0301\u0307",
+  // Ṥ = \'\.{S}
+  "\u0160": "S\u030C",
+  // Š = \v{S}
+  "\u1E66": "S\u030C\u0307",
+  // Ṧ = \v\.{S}
+  "\u015C": "S\u0302",
+  // Ŝ = \^{S}
+  "\u1E60": "S\u0307",
+  // Ṡ = \.{S}
+  "\u0164": "T\u030C",
+  // Ť = \v{T}
+  "\u1E6A": "T\u0307",
+  // Ṫ = \.{T}
+  "\xDA": "U\u0301",
+  // Ú = \'{U}
+  "\xD9": "U\u0300",
+  // Ù = \`{U}
+  "\xDC": "U\u0308",
+  // Ü = \"{U}
+  "\u01D7": "U\u0308\u0301",
+  // Ǘ = \"\'{U}
+  "\u01DB": "U\u0308\u0300",
+  // Ǜ = \"\`{U}
+  "\u01D5": "U\u0308\u0304",
+  // Ǖ = \"\={U}
+  "\u01D9": "U\u0308\u030C",
+  // Ǚ = \"\v{U}
+  "\u0168": "U\u0303",
+  // Ũ = \~{U}
+  "\u1E78": "U\u0303\u0301",
+  // Ṹ = \~\'{U}
+  "\u016A": "U\u0304",
+  // Ū = \={U}
+  "\u1E7A": "U\u0304\u0308",
+  // Ṻ = \=\"{U}
+  "\u016C": "U\u0306",
+  // Ŭ = \u{U}
+  "\u01D3": "U\u030C",
+  // Ǔ = \v{U}
+  "\xDB": "U\u0302",
+  // Û = \^{U}
+  "\u016E": "U\u030A",
+  // Ů = \r{U}
+  "\u0170": "U\u030B",
+  // Ű = \H{U}
+  "\u1E7C": "V\u0303",
+  // Ṽ = \~{V}
+  "\u1E82": "W\u0301",
+  // Ẃ = \'{W}
+  "\u1E80": "W\u0300",
+  // Ẁ = \`{W}
+  "\u1E84": "W\u0308",
+  // Ẅ = \"{W}
+  "\u0174": "W\u0302",
+  // Ŵ = \^{W}
+  "\u1E86": "W\u0307",
+  // Ẇ = \.{W}
+  "\u1E8C": "X\u0308",
+  // Ẍ = \"{X}
+  "\u1E8A": "X\u0307",
+  // Ẋ = \.{X}
+  "\xDD": "Y\u0301",
+  // Ý = \'{Y}
+  "\u1EF2": "Y\u0300",
+  // Ỳ = \`{Y}
+  "\u0178": "Y\u0308",
+  // Ÿ = \"{Y}
+  "\u1EF8": "Y\u0303",
+  // Ỹ = \~{Y}
+  "\u0232": "Y\u0304",
+  // Ȳ = \={Y}
+  "\u0176": "Y\u0302",
+  // Ŷ = \^{Y}
+  "\u1E8E": "Y\u0307",
+  // Ẏ = \.{Y}
+  "\u0179": "Z\u0301",
+  // Ź = \'{Z}
+  "\u017D": "Z\u030C",
+  // Ž = \v{Z}
+  "\u1E90": "Z\u0302",
+  // Ẑ = \^{Z}
+  "\u017B": "Z\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" // Ὼ = \`{Ω}
+
+});
 // CONCATENATED MODULE: ./src/Parser.js
 /* eslint no-constant-condition:0 */
 
@@ -15606,373 +16086,10 @@ function () {
 
 
 
- // Pre-evaluate both modules as unicodeSymbols require String.normalize()
 
-var unicodeAccents = {
-  "́": {
-    "text": "\\'",
-    "math": "\\acute"
-  },
-  "̀": {
-    "text": "\\`",
-    "math": "\\grave"
-  },
-  "̈": {
-    "text": "\\\"",
-    "math": "\\ddot"
-  },
-  "̃": {
-    "text": "\\~",
-    "math": "\\tilde"
-  },
-  "̄": {
-    "text": "\\=",
-    "math": "\\bar"
-  },
-  "̆": {
-    "text": "\\u",
-    "math": "\\breve"
-  },
-  "̌": {
-    "text": "\\v",
-    "math": "\\check"
-  },
-  "̂": {
-    "text": "\\^",
-    "math": "\\hat"
-  },
-  "̇": {
-    "text": "\\.",
-    "math": "\\dot"
-  },
-  "̊": {
-    "text": "\\r",
-    "math": "\\mathring"
-  },
-  "̋": {
-    "text": "\\H"
-  }
-};
-var unicodeSymbols = {
-  "á": "á",
-  "à": "à",
-  "ä": "ä",
-  "ǟ": "ǟ",
-  "ã": "ã",
-  "ā": "ā",
-  "ă": "ă",
-  "ắ": "ắ",
-  "ằ": "ằ",
-  "ẵ": "ẵ",
-  "ǎ": "ǎ",
-  "â": "â",
-  "ấ": "ấ",
-  "ầ": "ầ",
-  "ẫ": "ẫ",
-  "ȧ": "ȧ",
-  "ǡ": "ǡ",
-  "å": "å",
-  "ǻ": "ǻ",
-  "ḃ": "ḃ",
-  "ć": "ć",
-  "č": "č",
-  "ĉ": "ĉ",
-  "ċ": "ċ",
-  "ď": "ď",
-  "ḋ": "ḋ",
-  "é": "é",
-  "è": "è",
-  "ë": "ë",
-  "ẽ": "ẽ",
-  "ē": "ē",
-  "ḗ": "ḗ",
-  "ḕ": "ḕ",
-  "ĕ": "ĕ",
-  "ě": "ě",
-  "ê": "ê",
-  "ế": "ế",
-  "ề": "ề",
-  "ễ": "ễ",
-  "ė": "ė",
-  "ḟ": "ḟ",
-  "ǵ": "ǵ",
-  "ḡ": "ḡ",
-  "ğ": "ğ",
-  "ǧ": "ǧ",
-  "ĝ": "ĝ",
-  "ġ": "ġ",
-  "ḧ": "ḧ",
-  "ȟ": "ȟ",
-  "ĥ": "ĥ",
-  "ḣ": "ḣ",
-  "í": "í",
-  "ì": "ì",
-  "ï": "ï",
-  "ḯ": "ḯ",
-  "ĩ": "ĩ",
-  "ī": "ī",
-  "ĭ": "ĭ",
-  "ǐ": "ǐ",
-  "î": "î",
-  "ǰ": "ǰ",
-  "ĵ": "ĵ",
-  "ḱ": "ḱ",
-  "ǩ": "ǩ",
-  "ĺ": "ĺ",
-  "ľ": "ľ",
-  "ḿ": "ḿ",
-  "ṁ": "ṁ",
-  "ń": "ń",
-  "ǹ": "ǹ",
-  "ñ": "ñ",
-  "ň": "ň",
-  "ṅ": "ṅ",
-  "ó": "ó",
-  "ò": "ò",
-  "ö": "ö",
-  "ȫ": "ȫ",
-  "õ": "õ",
-  "ṍ": "ṍ",
-  "ṏ": "ṏ",
-  "ȭ": "ȭ",
-  "ō": "ō",
-  "ṓ": "ṓ",
-  "ṑ": "ṑ",
-  "ŏ": "ŏ",
-  "ǒ": "ǒ",
-  "ô": "ô",
-  "ố": "ố",
-  "ồ": "ồ",
-  "ỗ": "ỗ",
-  "ȯ": "ȯ",
-  "ȱ": "ȱ",
-  "ő": "ő",
-  "ṕ": "ṕ",
-  "ṗ": "ṗ",
-  "ŕ": "ŕ",
-  "ř": "ř",
-  "ṙ": "ṙ",
-  "ś": "ś",
-  "ṥ": "ṥ",
-  "š": "š",
-  "ṧ": "ṧ",
-  "ŝ": "ŝ",
-  "ṡ": "ṡ",
-  "ẗ": "ẗ",
-  "ť": "ť",
-  "ṫ": "ṫ",
-  "ú": "ú",
-  "ù": "ù",
-  "ü": "ü",
-  "ǘ": "ǘ",
-  "ǜ": "ǜ",
-  "ǖ": "ǖ",
-  "ǚ": "ǚ",
-  "ũ": "ũ",
-  "ṹ": "ṹ",
-  "ū": "ū",
-  "ṻ": "ṻ",
-  "ŭ": "ŭ",
-  "ǔ": "ǔ",
-  "û": "û",
-  "ů": "ů",
-  "ű": "ű",
-  "ṽ": "ṽ",
-  "ẃ": "ẃ",
-  "ẁ": "ẁ",
-  "ẅ": "ẅ",
-  "ŵ": "ŵ",
-  "ẇ": "ẇ",
-  "ẘ": "ẘ",
-  "ẍ": "ẍ",
-  "ẋ": "ẋ",
-  "ý": "ý",
-  "ỳ": "ỳ",
-  "ÿ": "ÿ",
-  "ỹ": "ỹ",
-  "ȳ": "ȳ",
-  "ŷ": "ŷ",
-  "ẏ": "ẏ",
-  "ẙ": "ẙ",
-  "ź": "ź",
-  "ž": "ž",
-  "ẑ": "ẑ",
-  "ż": "ż",
-  "Á": "Á",
-  "À": "À",
-  "Ä": "Ä",
-  "Ǟ": "Ǟ",
-  "Ã": "Ã",
-  "Ā": "Ā",
-  "Ă": "Ă",
-  "Ắ": "Ắ",
-  "Ằ": "Ằ",
-  "Ẵ": "Ẵ",
-  "Ǎ": "Ǎ",
-  "Â": "Â",
-  "Ấ": "Ấ",
-  "Ầ": "Ầ",
-  "Ẫ": "Ẫ",
-  "Ȧ": "Ȧ",
-  "Ǡ": "Ǡ",
-  "Å": "Å",
-  "Ǻ": "Ǻ",
-  "Ḃ": "Ḃ",
-  "Ć": "Ć",
-  "Č": "Č",
-  "Ĉ": "Ĉ",
-  "Ċ": "Ċ",
-  "Ď": "Ď",
-  "Ḋ": "Ḋ",
-  "É": "É",
-  "È": "È",
-  "Ë": "Ë",
-  "Ẽ": "Ẽ",
-  "Ē": "Ē",
-  "Ḗ": "Ḗ",
-  "Ḕ": "Ḕ",
-  "Ĕ": "Ĕ",
-  "Ě": "Ě",
-  "Ê": "Ê",
-  "Ế": "Ế",
-  "Ề": "Ề",
-  "Ễ": "Ễ",
-  "Ė": "Ė",
-  "Ḟ": "Ḟ",
-  "Ǵ": "Ǵ",
-  "Ḡ": "Ḡ",
-  "Ğ": "Ğ",
-  "Ǧ": "Ǧ",
-  "Ĝ": "Ĝ",
-  "Ġ": "Ġ",
-  "Ḧ": "Ḧ",
-  "Ȟ": "Ȟ",
-  "Ĥ": "Ĥ",
-  "Ḣ": "Ḣ",
-  "Í": "Í",
-  "Ì": "Ì",
-  "Ï": "Ï",
-  "Ḯ": "Ḯ",
-  "Ĩ": "Ĩ",
-  "Ī": "Ī",
-  "Ĭ": "Ĭ",
-  "Ǐ": "Ǐ",
-  "Î": "Î",
-  "İ": "İ",
-  "Ĵ": "Ĵ",
-  "Ḱ": "Ḱ",
-  "Ǩ": "Ǩ",
-  "Ĺ": "Ĺ",
-  "Ľ": "Ľ",
-  "Ḿ": "Ḿ",
-  "Ṁ": "Ṁ",
-  "Ń": "Ń",
-  "Ǹ": "Ǹ",
-  "Ñ": "Ñ",
-  "Ň": "Ň",
-  "Ṅ": "Ṅ",
-  "Ó": "Ó",
-  "Ò": "Ò",
-  "Ö": "Ö",
-  "Ȫ": "Ȫ",
-  "Õ": "Õ",
-  "Ṍ": "Ṍ",
-  "Ṏ": "Ṏ",
-  "Ȭ": "Ȭ",
-  "Ō": "Ō",
-  "Ṓ": "Ṓ",
-  "Ṑ": "Ṑ",
-  "Ŏ": "Ŏ",
-  "Ǒ": "Ǒ",
-  "Ô": "Ô",
-  "Ố": "Ố",
-  "Ồ": "Ồ",
-  "Ỗ": "Ỗ",
-  "Ȯ": "Ȯ",
-  "Ȱ": "Ȱ",
-  "Ő": "Ő",
-  "Ṕ": "Ṕ",
-  "Ṗ": "Ṗ",
-  "Ŕ": "Ŕ",
-  "Ř": "Ř",
-  "Ṙ": "Ṙ",
-  "Ś": "Ś",
-  "Ṥ": "Ṥ",
-  "Š": "Š",
-  "Ṧ": "Ṧ",
-  "Ŝ": "Ŝ",
-  "Ṡ": "Ṡ",
-  "Ť": "Ť",
-  "Ṫ": "Ṫ",
-  "Ú": "Ú",
-  "Ù": "Ù",
-  "Ü": "Ü",
-  "Ǘ": "Ǘ",
-  "Ǜ": "Ǜ",
-  "Ǖ": "Ǖ",
-  "Ǚ": "Ǚ",
-  "Ũ": "Ũ",
-  "Ṹ": "Ṹ",
-  "Ū": "Ū",
-  "Ṻ": "Ṻ",
-  "Ŭ": "Ŭ",
-  "Ǔ": "Ǔ",
-  "Û": "Û",
-  "Ů": "Ů",
-  "Ű": "Ű",
-  "Ṽ": "Ṽ",
-  "Ẃ": "Ẃ",
-  "Ẁ": "Ẁ",
-  "Ẅ": "Ẅ",
-  "Ŵ": "Ŵ",
-  "Ẇ": "Ẇ",
-  "Ẍ": "Ẍ",
-  "Ẋ": "Ẋ",
-  "Ý": "Ý",
-  "Ỳ": "Ỳ",
-  "Ÿ": "Ÿ",
-  "Ỹ": "Ỹ",
-  "Ȳ": "Ȳ",
-  "Ŷ": "Ŷ",
-  "Ẏ": "Ẏ",
-  "Ź": "Ź",
-  "Ž": "Ž",
-  "Ẑ": "Ẑ",
-  "Ż": "Ż",
-  "ά": "ά",
-  "ὰ": "ὰ",
-  "ᾱ": "ᾱ",
-  "ᾰ": "ᾰ",
-  "έ": "έ",
-  "ὲ": "ὲ",
-  "ή": "ή",
-  "ὴ": "ὴ",
-  "ί": "ί",
-  "ὶ": "ὶ",
-  "ϊ": "ϊ",
-  "ΐ": "ΐ",
-  "ῒ": "ῒ",
-  "ῑ": "ῑ",
-  "ῐ": "ῐ",
-  "ό": "ό",
-  "ὸ": "ὸ",
-  "ύ": "ύ",
-  "ὺ": "ὺ",
-  "ϋ": "ϋ",
-  "ΰ": "ΰ",
-  "ῢ": "ῢ",
-  "ῡ": "ῡ",
-  "ῠ": "ῠ",
-  "ώ": "ώ",
-  "ὼ": "ὼ",
-  "Ύ": "Ύ",
-  "Ὺ": "Ὺ",
-  "Ϋ": "Ϋ",
-  "Ῡ": "Ῡ",
-  "Ῠ": "Ῠ",
-  "Ώ": "Ώ",
-  "Ὼ": "Ὼ"
-};
+
+
+
 
 /**
  * This file contains the parser used to parse out a TeX expression from the
@@ -16080,15 +16197,12 @@ function () {
   ;
 
   _proto.parse = function parse() {
-    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.
+    // 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
@@ -16098,10 +16212,7 @@ function () {
 
     this.expect("EOF"); // End the group namespace for the expression
 
-    if (!this.settings.globalGroup) {
-      this.gullet.endGroup();
-    }
-
+    this.gullet.endGroup();
     return parse;
   };
 
@@ -16133,8 +16244,6 @@ function () {
 
       if (!atom) {
         break;
-      } else if (atom.type === "internal") {
-        continue;
       }
 
       body.push(atom);
@@ -16160,13 +16269,15 @@ function () {
     var funcName;
 
     for (var i = 0; i < body.length; i++) {
-      if (body[i].type === "infix") {
+      var node = checkNodeType(body[i], "infix");
+
+      if (node) {
         if (overIndex !== -1) {
-          throw new src_ParseError("only one infix operator per group", body[i].token);
+          throw new src_ParseError("only one infix operator per group", node.token);
         }
 
         overIndex = i;
-        funcName = body[i].replaceWith;
+        funcName = node.replaceWith;
       }
     }
 
@@ -16196,15 +16307,15 @@ function () {
         };
       }
 
-      var node;
+      var _node;
 
       if (funcName === "\\\\abovefrac") {
-        node = this.callFunction(funcName, [numerNode, body[overIndex], denomNode], []);
+        _node = this.callFunction(funcName, [numerNode, body[overIndex], denomNode], []);
       } else {
-        node = this.callFunction(funcName, [numerNode, denomNode], []);
+        _node = this.callFunction(funcName, [numerNode, denomNode], []);
       }
 
-      return [node];
+      return [_node];
     } else {
       return body;
     }
@@ -16282,16 +16393,22 @@ function () {
 
       if (lex.text === "\\limits" || lex.text === "\\nolimits") {
         // We got a limit control
-        if (base && base.type === "op") {
-          var limits = lex.text === "\\limits";
-          base.limits = limits;
-          base.alwaysHandleSupSub = true;
-        } else if (base && base.type === "operatorname" && base.alwaysHandleSupSub) {
-          var _limits = lex.text === "\\limits";
+        var opNode = checkNodeType(base, "op");
 
-          base.limits = _limits;
+        if (opNode) {
+          var limits = lex.text === "\\limits";
+          opNode.limits = limits;
+          opNode.alwaysHandleSupSub = true;
         } else {
-          throw new src_ParseError("Limit controls must follow a math operator", lex);
+          opNode = checkNodeType(base, "operatorname");
+
+          if (opNode && opNode.alwaysHandleSupSub) {
+            var _limits = lex.text === "\\limits";
+
+            opNode.limits = _limits;
+          } else {
+            throw new src_ParseError("Limit controls must follow a math operator", lex);
+          }
         }
 
         this.consume();
@@ -17209,7 +17326,7 @@ var katex_renderToHTMLTree = function renderToHTMLTree(expression, options) {
   /**
    * Current KaTeX version
    */
-  version: "0.12.0",
+  version: "0.11.1",
 
   /**
    * Renders the given LaTeX into an HTML+MathML combination, and adds