jekyll-theme-hydejack 8.3.2 → 8.4.0

data/assets/bower_components/katex/dist/katex.css

@@ -967,10 +967,7 @@
 .katex .boxpad {
   padding: 0 0.3em 0 0.3em;
 }
-.katex .fbox {
-  box-sizing: border-box;
-  border: 0.04em solid black;
-}
+.katex .fbox,
 .katex .fcolorbox {
   box-sizing: border-box;
   border: 0.04em solid;
@@ -1004,4 +1001,11 @@
   position: absolute;
   right: 0;
 }
+.katex-display.leqno > .katex > .katex-html > .tag {
+  left: 0;
+  right: auto;
+}
+.katex-display.fleqn > .katex {
+  text-align: left;
+}
 

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

@@ -91,7 +91,7 @@ return /******/ (function(modules) { // webpackBootstrap
 /******/
 /******/
 /******/ 	// Load entry module and return exports
-/******/ 	return __webpack_require__(__webpack_require__.s = 2);
+/******/ 	return __webpack_require__(__webpack_require__.s = 1);
 /******/ })
 /************************************************************************/
 /******/ ([
@@ -101,8 +101,7 @@ return /******/ (function(modules) { // webpackBootstrap
 // extracted by mini-css-extract-plugin
 
 /***/ }),
-/* 1 */,
-/* 2 */
+/* 1 */
 /***/ (function(module, __webpack_exports__, __webpack_require__) {
 
 "use strict";
@@ -131,12 +130,6 @@ function () {
     this.start = start;
     this.end = end;
   }
-
-  var _proto = SourceLocation.prototype;
-
-  _proto.getSource = function getSource() {
-    return this.lexer.input.slice(this.start, this.end);
-  };
   /**
    * Merges two `SourceLocation`s from location providers, given they are
    * provided in order of appearance.
@@ -403,6 +396,8 @@ var Settings_Settings =
 function () {
   function Settings(options) {
     this.displayMode = void 0;
+    this.leqno = void 0;
+    this.fleqn = void 0;
     this.throwOnError = void 0;
     this.errorColor = void 0;
     this.macros = void 0;
@@ -414,6 +409,8 @@ function () {
     // allow null options
     options = options || {};
     this.displayMode = utils.deflt(options.displayMode, false);
+    this.leqno = utils.deflt(options.leqno, false);
+    this.fleqn = utils.deflt(options.fleqn, false);
     this.throwOnError = utils.deflt(options.throwOnError, true);
     this.errorColor = utils.deflt(options.errorColor, "#cc0000");
     this.macros = options.macros || {};
@@ -450,7 +447,7 @@ function () {
       // won't happen in type-safe code
       typeof console !== "undefined" && console.warn("LaTeX-incompatible input and strict mode is set to " + ("unrecognized '" + strict + "': " + errorMsg + " [" + errorCode + "]"));
     }
-  };
+  }
   /**
    * Check whether to apply strict (LaTeX-adhering) behavior for unusual
    * input (like `\\`).  Unlike `nonstrict`, will not throw an error;
@@ -459,7 +456,7 @@ function () {
    * "warn" prints a warning and returns `false`.
    * This is for the second category of `errorCode`s listed in the README.
    */
-
+  ;
 
   _proto.useStrictBehavior = function useStrictBehavior(errorCode, errorMsg, token) {
     var strict = this.strict;
@@ -527,54 +524,54 @@ function () {
 
   _proto.sup = function sup() {
     return Style_styles[_sup[this.id]];
-  };
+  }
   /**
    * Get the style of a subscript given a base in the current style.
    */
-
+  ;
 
   _proto.sub = function sub() {
     return Style_styles[_sub[this.id]];
-  };
+  }
   /**
    * Get the style of a fraction numerator given the fraction in the current
    * style.
    */
-
+  ;
 
   _proto.fracNum = function fracNum() {
     return Style_styles[_fracNum[this.id]];
-  };
+  }
   /**
    * Get the style of a fraction denominator given the fraction in the current
    * style.
    */
-
+  ;
 
   _proto.fracDen = function fracDen() {
     return Style_styles[_fracDen[this.id]];
-  };
+  }
   /**
    * Get the cramped version of a style (in particular, cramping a cramped style
    * doesn't change the style).
    */
-
+  ;
 
   _proto.cramp = function cramp() {
     return Style_styles[_cramp[this.id]];
-  };
+  }
   /**
    * Get a text or display version of this style.
    */
-
+  ;
 
   _proto.text = function text() {
     return Style_styles[_text[this.id]];
-  };
+  }
   /**
    * Return true if this style is tightly spaced (scriptstyle/scriptscriptstyle)
    */
-
+  ;
 
   _proto.isTight = function isTight() {
     return this.size >= 2;
@@ -810,7 +807,7 @@ var svgGeometry_path = {
   // The next ten paths support reaction arrows from the mhchem package.
   // Arrows for \ce{<-->} are offset from xAxis by 0.22ex, per mhchem in LaTeX
   // baraboveleftarrow is mostly from from glyph U+2190 in font KaTeX Main
-  baraboveleftarrow: "M400000 620h-399890l3 -3c68.7 -52.7 113.7 -120 135 -202\nc4 -14.7 6 -23 6 -25c0 -7.3 -7 -11 -21 -11c-8 0 -13.2 0.8 -15.5 2.5\nc-2.3 1.7 -4.2 5.8 -5.5 12.5c-1.3 4.7 -2.7 10.3 -4 17c-12 48.7 -34.8 92 -68.5 130\ns-74.2 66.3 -121.5 85c-10 4 -16 7.7 -18 11c0 8.7 6 14.3 18 17c47.3 18.7 87.8 47\n121.5 85s56.5 81.3 68.5 130c0.7 2 1.3 5 2 9s1.2 6.7 1.5 8c0.3 1.3 1 3.3 2 6\ns2.2 4.5 3.5 5.5c1.3 1 3.3 1.8 6 2.5s6 1 10 1c14 0 21 -3.7 21 -11\nc0 -2 -2 -10.3 -6 -25c-20 -79.3 -65 -146.7 -135 -202l-3 -3h399890z\nM100 241v40h399900v-40z M0 241v40h399900v-40zM0 241v40h399900v-40z",
+  baraboveleftarrow: "M400000 620h-399890l3 -3c68.7 -52.7 113.7 -120 135 -202\nc4 -14.7 6 -23 6 -25c0 -7.3 -7 -11 -21 -11c-8 0 -13.2 0.8 -15.5 2.5\nc-2.3 1.7 -4.2 5.8 -5.5 12.5c-1.3 4.7 -2.7 10.3 -4 17c-12 48.7 -34.8 92 -68.5 130\ns-74.2 66.3 -121.5 85c-10 4 -16 7.7 -18 11c0 8.7 6 14.3 18 17c47.3 18.7 87.8 47\n121.5 85s56.5 81.3 68.5 130c0.7 2 1.3 5 2 9s1.2 6.7 1.5 8c0.3 1.3 1 3.3 2 6\ns2.2 4.5 3.5 5.5c1.3 1 3.3 1.8 6 2.5s6 1 10 1c14 0 21 -3.7 21 -11\nc0 -2 -2 -10.3 -6 -25c-20 -79.3 -65 -146.7 -135 -202l-3 -3h399890z\nM100 620v40h399900v-40z M0 241v40h399900v-40zM0 241v40h399900v-40z",
   // rightarrowabovebar is mostly from glyph U+2192, KaTeX Main
   rightarrowabovebar: "M0 241v40h399891c-47.3 35.3-84 78-110 128-16.7 32\n-27.7 63.7-33 95 0 1.3-.2 2.7-.5 4-.3 1.3-.5 2.3-.5 3 0 7.3 6.7 11 20 11 8 0\n13.2-.8 15.5-2.5 2.3-1.7 4.2-5.5 5.5-11.5 2-13.3 5.7-27 11-41 14.7-44.7 39\n-84.5 73-119.5s73.7-60.2 119-75.5c6-2 9-5.7 9-11s-3-9-9-11c-45.3-15.3-85-40.5\n-119-75.5s-58.3-74.8-73-119.5c-4.7-14-8.3-27.3-11-40-1.3-6.7-3.2-10.8-5.5\n-12.5-2.3-1.7-7.5-2.5-15.5-2.5-14 0-21 3.7-21 11 0 2 2 10.3 6 25 20.7 83.3 67\n151.7 139 205zm96 379h399894v40H0zm0 0h399904v40H0z",
   // The short left harpoon has 0.5em (i.e. 500 units) kern on the left end.
@@ -855,9 +852,9 @@ function () {
 
   _proto.hasClass = function hasClass(className) {
     return utils.contains(this.classes, className);
-  };
+  }
   /** Convert the fragment into a node. */
-
+  ;
 
   _proto.toNode = function toNode() {
     var frag = document.createDocumentFragment();
@@ -867,9 +864,9 @@ function () {
     }
 
     return frag;
-  };
+  }
   /** Convert the fragment into HTML markup. */
-
+  ;
 
   _proto.toMarkup = function toMarkup() {
     var markup = ""; // Simply concatenate the markup for the children together.
@@ -879,12 +876,12 @@ function () {
     }
 
     return markup;
-  };
+  }
   /**
    * Converts the math node into a string, similar to innerText. Applies to
    * MathDomNode's only.
    */
-
+  ;
 
   _proto.toText = function toText() {
     // To avoid this, we would subclass documentFragment separately for
@@ -1176,12 +1173,12 @@ function () {
 
   _proto3.hasClass = function hasClass(className) {
     return utils.contains(this.classes, className);
-  };
+  }
   /**
    * Creates a text node or span from a symbol node. Note that a span is only
    * created if it is needed.
    */
-
+  ;
 
   _proto3.toNode = function toNode() {
     var node = document.createTextNode(this.text);
@@ -1211,11 +1208,11 @@ function () {
     } else {
       return node;
     }
-  };
+  }
   /**
    * Creates markup for a symbol node.
    */
-
+  ;
 
   _proto3.toMarkup = function toMarkup() {
     // TODO(alpert): More duplication than I'd like from
@@ -1913,7 +1910,6 @@ function assertSpan(group) {
     "730": [0, 0.69444, 0, 0, 0.86944],
     "732": [0, 0.69444, 0, 0, 0.575],
     "733": [0, 0.69444, 0, 0, 0.575],
-    "824": [0.19444, 0.69444, 0, 0, 0],
     "915": [0, 0.68611, 0, 0, 0.69166],
     "916": [0, 0.68611, 0, 0, 0.95833],
     "920": [0, 0.68611, 0, 0, 0.89444],
@@ -2041,7 +2037,8 @@ function assertSpan(group) {
     "10217": [0.25, 0.75, 0, 0, 0.44722],
     "10815": [0, 0.68611, 0, 0, 0.9],
     "10927": [0.19667, 0.69667, 0, 0, 0.89444],
-    "10928": [0.19667, 0.69667, 0, 0, 0.89444]
+    "10928": [0.19667, 0.69667, 0, 0, 0.89444],
+    "57376": [0.19444, 0.69444, 0, 0, 0]
   },
   "Main-BoldItalic": {
     "33": [0, 0.69444, 0.11417, 0, 0.38611],
@@ -2424,7 +2421,6 @@ function assertSpan(group) {
     "730": [0, 0.69444, 0, 0, 0.75],
     "732": [0, 0.66786, 0, 0, 0.5],
     "733": [0, 0.69444, 0, 0, 0.5],
-    "824": [0.19444, 0.69444, 0, 0, 0],
     "915": [0, 0.68333, 0, 0, 0.625],
     "916": [0, 0.68333, 0, 0, 0.83334],
     "920": [0, 0.68333, 0, 0, 0.77778],
@@ -2509,7 +2505,6 @@ function assertSpan(group) {
     "8776": [-0.01688, 0.48312, 0, 0, 0.77778],
     "8781": [-0.03625, 0.46375, 0, 0, 0.77778],
     "8784": [-0.133, 0.67, 0, 0, 0.778],
-    "8800": [0.215, 0.716, 0, 0, 0.778],
     "8801": [-0.03625, 0.46375, 0, 0, 0.77778],
     "8804": [0.13597, 0.63597, 0, 0, 0.77778],
     "8805": [0.13597, 0.63597, 0, 0, 0.77778],
@@ -2576,10 +2571,10 @@ function assertSpan(group) {
     "10236": [0.011, 0.511, 0, 0, 1.638],
     "10815": [0, 0.68333, 0, 0, 0.75],
     "10927": [0.13597, 0.63597, 0, 0, 0.77778],
-    "10928": [0.13597, 0.63597, 0, 0, 0.77778]
+    "10928": [0.13597, 0.63597, 0, 0, 0.77778],
+    "57376": [0.19444, 0.69444, 0, 0, 0]
   },
   "Math-BoldItalic": {
-    "47": [0.19444, 0.69444, 0, 0, 0],
     "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],
@@ -2675,7 +2670,6 @@ function assertSpan(group) {
     "1013": [0, 0.44444, 0, 0, 0.48333]
   },
   "Math-Italic": {
-    "47": [0.19444, 0.69444, 0, 0, 0],
     "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],
@@ -3820,7 +3814,7 @@ function getGlobalMetrics(size) {
      normal font), or "ams" (the ams fonts).
  * - group (required): the ParseNode group type the symbol should have (i.e.
      "textord", "mathord", etc).
-     See https://github.com/Khan/KaTeX/wiki/Examining-TeX#group-types
+     See https://github.com/KaTeX/KaTeX/wiki/Examining-TeX#group-types
  * - replace: the character that this symbol or function should be
  *   replaced with (i.e. "\phi" has a replace value of "\u03d5", the phi
  *   character in the main font).
@@ -4346,7 +4340,7 @@ defineSymbol(symbols_math, main, rel, "\u2265", "\\geq", true);
 defineSymbol(symbols_math, main, rel, "\u2190", "\\gets");
 defineSymbol(symbols_math, main, rel, ">", "\\gt");
 defineSymbol(symbols_math, main, rel, "\u2208", "\\in", true);
-defineSymbol(symbols_math, main, rel, "\u0338", "\\@not");
+defineSymbol(symbols_math, main, rel, "\uE020", "\\@not");
 defineSymbol(symbols_math, main, rel, "\u2282", "\\subset", true);
 defineSymbol(symbols_math, main, rel, "\u2283", "\\supset", true);
 defineSymbol(symbols_math, main, rel, "\u2286", "\\subseteq", true);
@@ -4422,6 +4416,8 @@ defineSymbol(symbols_math, main, symbols_textord, "\u2225", "\\|");
 defineSymbol(symbols_math, main, symbols_textord, "\u2225", "\\Vert");
 defineSymbol(symbols_text, main, symbols_textord, "\u2225", "\\textbardbl");
 defineSymbol(symbols_text, main, symbols_textord, "~", "\\textasciitilde");
+defineSymbol(symbols_text, main, symbols_textord, "\\", "\\textbackslash");
+defineSymbol(symbols_text, main, symbols_textord, "^", "\\textasciicircum");
 defineSymbol(symbols_math, main, rel, "\u2191", "\\uparrow", true);
 defineSymbol(symbols_math, main, rel, "\u21D1", "\\Uparrow", true);
 defineSymbol(symbols_math, main, rel, "\u2193", "\\downarrow", true);
@@ -4564,13 +4560,32 @@ for (var symbols_i2 = 0; symbols_i2 < letters.length; symbols_i2++) {
 
   defineSymbol(symbols_math, main, mathord, _ch2, _ch2);
   defineSymbol(symbols_text, main, symbols_textord, _ch2, _ch2);
-} // The next loop loads wide (surrogate pair) characters.
+} // Blackboard bold and script letters in Unicode range
+
+
+defineSymbol(symbols_math, ams, symbols_textord, "C", "\u2102"); // blackboard bold
+
+defineSymbol(symbols_text, ams, symbols_textord, "C", "\u2102");
+defineSymbol(symbols_math, ams, symbols_textord, "H", "\u210D");
+defineSymbol(symbols_text, ams, symbols_textord, "H", "\u210D");
+defineSymbol(symbols_math, ams, symbols_textord, "N", "\u2115");
+defineSymbol(symbols_text, ams, symbols_textord, "N", "\u2115");
+defineSymbol(symbols_math, ams, symbols_textord, "P", "\u2119");
+defineSymbol(symbols_text, ams, symbols_textord, "P", "\u2119");
+defineSymbol(symbols_math, ams, symbols_textord, "Q", "\u211A");
+defineSymbol(symbols_text, ams, symbols_textord, "Q", "\u211A");
+defineSymbol(symbols_math, ams, symbols_textord, "R", "\u211D");
+defineSymbol(symbols_text, ams, symbols_textord, "R", "\u211D");
+defineSymbol(symbols_math, ams, symbols_textord, "Z", "\u2124");
+defineSymbol(symbols_text, ams, symbols_textord, "Z", "\u2124");
+defineSymbol(symbols_math, main, mathord, "h", "\u210E"); // italic h, Planck constant
+
+defineSymbol(symbols_text, main, mathord, "h", "\u210E"); // The next loop loads wide (surrogate pair) characters.
 // We support some letters in the Unicode range U+1D400 to U+1D7FF,
 // Mathematical Alphanumeric Symbols.
 // Some editors do not deal well with wide characters. So don't write the
 // string into this file. Instead, create the string from the surrogate pair.
 
-
 var symbols_wideChar = "";
 
 for (var _i3 = 0; _i3 < letters.length; _i3++) {
@@ -4858,12 +4873,12 @@ function () {
     }
 
     return new Options(data);
-  };
+  }
   /**
    * Return an options object with the given style. If `this.style === style`,
    * returns `this`.
    */
-
+  ;
 
   _proto.havingStyle = function havingStyle(style) {
     if (this.style === style) {
@@ -4874,21 +4889,21 @@ function () {
         size: sizeAtStyle(this.textSize, style)
       });
     }
-  };
+  }
   /**
    * Return an options object with a cramped version of the current style. If
    * the current style is cramped, returns `this`.
    */
-
+  ;
 
   _proto.havingCrampedStyle = function havingCrampedStyle() {
     return this.havingStyle(this.style.cramp());
-  };
+  }
   /**
    * Return an options object with the given size and in at least `\textstyle`.
    * Returns `this` if appropriate.
    */
-
+  ;
 
   _proto.havingSize = function havingSize(size) {
     if (this.size === size && this.textSize === size) {
@@ -4901,12 +4916,12 @@ function () {
         sizeMultiplier: sizeMultipliers[size - 1]
       });
     }
-  };
+  }
   /**
    * Like `this.havingSize(BASESIZE).havingStyle(style)`. If `style` is omitted,
    * changes to at least `\textstyle`.
    */
-
+  ;
 
   _proto.havingBaseStyle = function havingBaseStyle(style) {
     style = style || this.style.text();
@@ -4920,12 +4935,12 @@ function () {
         size: wantSize
       });
     }
-  };
+  }
   /**
    * Remove the effect of sizing changes such as \Huge.
    * Keep the effect of the current style, such as \scriptstyle.
    */
-
+  ;
 
   _proto.havingBaseSizing = function havingBaseSizing() {
     var size;
@@ -4952,76 +4967,76 @@ function () {
       style: this.style.text(),
       size: size
     });
-  };
+  }
   /**
    * Create a new options object with the given color.
    */
-
+  ;
 
   _proto.withColor = function withColor(color) {
     return this.extend({
       color: color
     });
-  };
+  }
   /**
    * Create a new options object with "phantom" set to true.
    */
-
+  ;
 
   _proto.withPhantom = function withPhantom() {
     return this.extend({
       phantom: true
     });
-  };
+  }
   /**
    * Creates a new options object with the given math font or old text font.
    * @type {[type]}
    */
-
+  ;
 
   _proto.withFont = function withFont(font) {
     return this.extend({
       font: font
     });
-  };
+  }
   /**
    * Create a new options objects with the given fontFamily.
    */
-
+  ;
 
   _proto.withTextFontFamily = function withTextFontFamily(fontFamily) {
     return this.extend({
       fontFamily: fontFamily,
       font: ""
     });
-  };
+  }
   /**
    * Creates a new options object with the given font weight
    */
-
+  ;
 
   _proto.withTextFontWeight = function withTextFontWeight(fontWeight) {
     return this.extend({
       fontWeight: fontWeight,
       font: ""
     });
-  };
+  }
   /**
    * Creates a new options object with the given font weight
    */
-
+  ;
 
   _proto.withTextFontShape = function withTextFontShape(fontShape) {
     return this.extend({
       fontShape: fontShape,
       font: ""
     });
-  };
+  }
   /**
    * Return the CSS sizing classes required to switch from enclosing options
    * `oldOptions` to `this`. Returns an array of classes.
    */
-
+  ;
 
   _proto.sizingClasses = function sizingClasses(oldOptions) {
     if (oldOptions.size !== this.size) {
@@ -5029,12 +5044,12 @@ function () {
     } else {
       return [];
     }
-  };
+  }
   /**
    * Return the CSS sizing classes required to switch to the base size. Like
    * `this.havingSize(BASESIZE).sizingClasses(this)`.
    */
-
+  ;
 
   _proto.baseSizingClasses = function baseSizingClasses() {
     if (this.size !== Options.BASESIZE) {
@@ -5042,11 +5057,11 @@ function () {
     } else {
       return [];
     }
-  };
+  }
   /**
    * Return the font metrics for this size.
    */
-
+  ;
 
   _proto.fontMetrics = function fontMetrics() {
     if (!this._fontMetrics) {
@@ -5054,12 +5069,12 @@ function () {
     }
 
     return this._fontMetrics;
-  };
+  }
   /**
    * A map of color names to CSS colors.
    * TODO(emily): Remove this when we have real macros
    */
-
+  ;
 
   /**
    * Gets the CSS color of the current options object, accounting for the
@@ -6270,25 +6285,8 @@ var buildHTML_makeSpan = buildCommon.makeSpan; // Binary atoms (first class `mbi
 // depending on their surroundings. See TeXbook pg. 442-446, Rules 5 and 6,
 // and the text before Rule 19.
 
-var buildHTML_isBinLeftCanceller = function isBinLeftCanceller(node, isRealGroup) {
-  // TODO: This code assumes that a node's math class is the first element
-  // of its `classes` array. A later cleanup should ensure this, for
-  // instance by changing the signature of `makeSpan`.
-  if (node) {
-    return utils.contains(["mbin", "mopen", "mrel", "mop", "mpunct"], getTypeOfDomTree(node, "right"));
-  } else {
-    return isRealGroup;
-  }
-};
-
-var buildHTML_isBinRightCanceller = function isBinRightCanceller(node, isRealGroup) {
-  if (node) {
-    return utils.contains(["mrel", "mclose", "mpunct"], getTypeOfDomTree(node, "left"));
-  } else {
-    return isRealGroup;
-  }
-};
-
+var binLeftCanceller = ["leftmost", "mbin", "mopen", "mrel", "mop", "mpunct"];
+var binRightCanceller = ["rightmost", "mrel", "mclose", "mpunct"];
 var buildHTML_styleMap = {
   "display": src_Style.DISPLAY,
   "text": src_Style.TEXT,
@@ -6320,114 +6318,159 @@ var buildHTML_buildExpression = function buildExpression(expression, options, is
   }
 
   // Parse expressions into `groups`.
-  var rawGroups = [];
+  var groups = [];
 
   for (var i = 0; i < expression.length; i++) {
     var output = buildHTML_buildGroup(expression[i], options);
 
     if (output instanceof tree_DocumentFragment) {
       var children = output.children;
-      rawGroups.push.apply(rawGroups, children);
+      groups.push.apply(groups, children);
     } else {
-      rawGroups.push(output);
+      groups.push(output);
     }
-  } // At this point `rawGroups` consists entirely of `symbolNode`s and `span`s.
-  // Ignore explicit spaces (e.g., \;, \,) when determining what implicit
-  // spacing should go between atoms of different classes, and add dummy
-  // spans for determining spacings between surrounding atoms.
+  } // If `expression` is a partial group, let the parent handle spacings
+  // to avoid processing groups multiple times.
 
 
-  var nonSpaces = [surrounding[0] ? buildHTML_makeSpan([surrounding[0]], [], options) : null].concat(rawGroups.filter(function (group) {
-    return group && group.classes[0] !== "mspace";
-  }), [surrounding[1] ? buildHTML_makeSpan([surrounding[1]], [], options) : null]); // Before determining what spaces to insert, perform bin cancellation.
-  // Binary operators change to ordinary symbols in some contexts.
+  if (!isRealGroup) {
+    return groups;
+  }
+
+  var glueOptions = options;
 
-  for (var _i = 1; _i < nonSpaces.length - 1; _i++) {
-    var nonSpacesI = assert(nonSpaces[_i]);
-    var left = buildHTML_getOutermostNode(nonSpacesI, "left");
+  if (expression.length === 1) {
+    var node = checkNodeType(expression[0], "sizing") || checkNodeType(expression[0], "styling");
 
-    if (left.classes[0] === "mbin" && buildHTML_isBinLeftCanceller(nonSpaces[_i - 1], isRealGroup)) {
-      left.classes[0] = "mord";
+    if (!node) {// No match.
+    } else if (node.type === "sizing") {
+      glueOptions = options.havingSize(node.size);
+    } else if (node.type === "styling") {
+      glueOptions = options.havingStyle(buildHTML_styleMap[node.style]);
     }
+  } // Dummy spans for determining spacings between surrounding atoms.
+  // If `expression` has no atoms on the left or right, class "leftmost"
+  // or "rightmost", respectively, is used to indicate it.
+
+
+  var dummyPrev = buildHTML_makeSpan([surrounding[0] || "leftmost"], [], options);
+  var dummyNext = buildHTML_makeSpan([surrounding[1] || "rightmost"], [], options); // TODO: These code assumes that a node's math class is the first element
+  // of its `classes` array. A later cleanup should ensure this, for
+  // instance by changing the signature of `makeSpan`.
+  // Before determining what spaces to insert, perform bin cancellation.
+  // Binary operators change to ordinary symbols in some contexts.
 
-    var right = buildHTML_getOutermostNode(nonSpacesI, "right");
+  traverseNonSpaceNodes(groups, function (node, prev) {
+    var prevType = prev.classes[0];
+    var type = node.classes[0];
 
-    if (right.classes[0] === "mbin" && buildHTML_isBinRightCanceller(nonSpaces[_i + 1], isRealGroup)) {
-      right.classes[0] = "mord";
+    if (prevType === "mbin" && utils.contains(binRightCanceller, type)) {
+      prev.classes[0] = "mord";
+    } else if (type === "mbin" && utils.contains(binLeftCanceller, prevType)) {
+      node.classes[0] = "mord";
     }
-  }
+  }, {
+    node: dummyPrev
+  }, dummyNext);
+  traverseNonSpaceNodes(groups, function (node, prev) {
+    var prevType = getTypeOfDomTree(prev);
+    var type = getTypeOfDomTree(node); // 'mtight' indicates that the node is script or scriptscript style.
 
-  var groups = [];
-  var j = 0;
+    var space = prevType && type ? node.hasClass("mtight") ? tightSpacings[prevType][type] : spacings[prevType][type] : null;
 
-  for (var _i2 = 0; _i2 < rawGroups.length; _i2++) {
-    groups.push(rawGroups[_i2]); // For any group that is not a space, get the next non-space.  Then
-    // lookup what implicit space should be placed between those atoms and
-    // add it to groups.
+    if (space) {
+      // Insert glue (spacing) after the `prev`.
+      return buildCommon.makeGlue(space, glueOptions);
+    }
+  }, {
+    node: dummyPrev
+  }, 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
+// previous node. `prev` is an object with the previous node and `insertAfter`
+// 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) {
+  if (next) {
+    // temporarily append the right node, if exists
+    nodes.push(next);
+  }
 
-    if (rawGroups[_i2].classes[0] !== "mspace" && j < nonSpaces.length - 1) {
-      // if current non-space node is left dummy span, add a glue before
-      // first real non-space node
-      if (j === 0) {
-        groups.pop();
-        _i2--;
-      } // Get the type of the current non-space node.  If it's a document
-      // fragment, get the type of the rightmost node in the fragment.
+  var i = 0;
 
+  for (; i < nodes.length; i++) {
+    var node = nodes[i];
+    var partialGroup = buildHTML_checkPartialGroup(node);
 
-      var _left = getTypeOfDomTree(nonSpaces[j], "right"); // Get the type of the next non-space node.  If it's a document
-      // fragment, get the type of the leftmost node in the fragment.
+    if (partialGroup) {
+      // Recursive DFS
+      traverseNonSpaceNodes(partialGroup.children, callback, prev);
+      continue;
+    } // Ignore explicit spaces (e.g., \;, \,) when determining what implicit
+    // spacing should go between atoms of different classes
 
 
-      var _right = getTypeOfDomTree(nonSpaces[j + 1], "left"); // We use buildExpression inside of sizingGroup, but it returns a
-      // document fragment of elements.  sizingGroup sets `isRealGroup`
-      // to false to avoid processing spans multiple times.
+    if (node.classes[0] === "mspace") {
+      continue;
+    }
 
+    var result = callback(node, prev.node);
 
-      if (_left && _right && isRealGroup) {
-        var nonSpacesJp1 = assert(nonSpaces[j + 1]);
-        var space = isLeftTight(nonSpacesJp1) ? tightSpacings[_left][_right] : spacings[_left][_right];
+    if (result) {
+      if (prev.insertAfter) {
+        prev.insertAfter(result);
+      } else {
+        // insert at front
+        nodes.unshift(result);
+        i++;
+      }
+    }
 
-        if (space) {
-          var glueOptions = options;
+    prev.node = node;
 
-          if (expression.length === 1) {
-            var node = checkNodeType(expression[0], "sizing") || checkNodeType(expression[0], "styling");
+    prev.insertAfter = function (index) {
+      return function (n) {
+        nodes.splice(index + 1, 0, n);
+        i++;
+      };
+    }(i);
+  }
 
-            if (!node) {// No match.
-            } else if (node.type === "sizing") {
-              glueOptions = options.havingSize(node.size);
-            } else if (node.type === "styling") {
-              glueOptions = options.havingStyle(buildHTML_styleMap[node.style]);
-            }
-          }
+  if (next) {
+    nodes.pop();
+  }
+}; // Check if given node is a partial group, i.e., does not affect spacing around.
 
-          groups.push(buildCommon.makeGlue(space, glueOptions));
-        }
-      }
 
-      j++;
-    }
+var buildHTML_checkPartialGroup = function checkPartialGroup(node) {
+  if (node instanceof tree_DocumentFragment || node instanceof domTree_Anchor) {
+    return node;
   }
 
-  return groups;
+  return null;
 }; // Return the outermost node of a domTree.
 
-var buildHTML_getOutermostNode = function getOutermostNode(node, side) {
-  if (node instanceof tree_DocumentFragment || node instanceof domTree_Anchor) {
-    var children = node.children;
+
+var getOutermostNode = function getOutermostNode(node, side) {
+  var partialGroup = buildHTML_checkPartialGroup(node);
+
+  if (partialGroup) {
+    var children = partialGroup.children;
 
     if (children.length) {
       if (side === "right") {
         return getOutermostNode(children[children.length - 1], "right");
       } else if (side === "left") {
-        return getOutermostNode(children[0], "right");
+        return getOutermostNode(children[0], "left");
       }
     }
   }
 
   return node;
 }; // Return math atom class (mclass) of a domTree.
+// If `side` is given, it will get the type of the outermost node at given side.
 
 
 var getTypeOfDomTree = function getTypeOfDomTree(node, side) {
@@ -6435,18 +6478,13 @@ var getTypeOfDomTree = function getTypeOfDomTree(node, side) {
     return null;
   }
 
-  node = buildHTML_getOutermostNode(node, side); // This makes a lot of assumptions as to where the type of atom
+  if (side) {
+    node = getOutermostNode(node, side);
+  } // This makes a lot of assumptions as to where the type of atom
   // appears.  We should do a better job of enforcing this.
 
+
   return DomEnum[node.classes[0]] || null;
-}; // If `node` is an atom return whether it's been assigned the mtight class.
-// If `node` is a document fragment, return the value of isLeftTight() for the
-// leftmost node in the fragment.
-// 'mtight' indicates that the node is script or scriptscript style.
-
-var isLeftTight = function isLeftTight(node) {
-  node = buildHTML_getOutermostNode(node, "left");
-  return node.hasClass("mtight");
 };
 var makeNullDelimiter = function makeNullDelimiter(options, classes) {
   var moreClasses = ["nulldelimiter"].concat(options.baseSizingClasses());
@@ -6534,10 +6572,10 @@ function buildHTML(tree, options) {
 
     if (expression[i].hasClass("mbin") || expression[i].hasClass("mrel") || expression[i].hasClass("allowbreak")) {
       // Put any post-operator glue on same line as operator.
-      // Watch for \nobreak along the way.
+      // Watch for \nobreak along the way, and stop at \newline.
       var nobreak = false;
 
-      while (i < expression.length - 1 && expression[i + 1].hasClass("mspace")) {
+      while (i < expression.length - 1 && expression[i + 1].hasClass("mspace") && !expression[i + 1].hasClass("newline")) {
         i++;
         parts.push(expression[i]);
 
@@ -6632,19 +6670,19 @@ function () {
 
   _proto.setAttribute = function setAttribute(name, value) {
     this.attributes[name] = value;
-  };
+  }
   /**
    * Gets an attribute on a MathML node.
    */
-
+  ;
 
   _proto.getAttribute = function getAttribute(name) {
     return this.attributes[name];
-  };
+  }
   /**
    * Converts the math node into a MathML-namespaced DOM element.
    */
-
+  ;
 
   _proto.toNode = function toNode() {
     var node = document.createElementNS("http://www.w3.org/1998/Math/MathML", this.type);
@@ -6660,11 +6698,11 @@ function () {
     }
 
     return node;
-  };
+  }
   /**
    * Converts the math node into an HTML markup string.
    */
-
+  ;
 
   _proto.toMarkup = function toMarkup() {
     var markup = "<" + this.type; // Add the attributes
@@ -6685,11 +6723,11 @@ function () {
 
     markup += "</" + this.type + ">";
     return markup;
-  };
+  }
   /**
    * Converts the math node into a string, similar to innerText, but escaped.
    */
-
+  ;
 
   _proto.toText = function toText() {
     return this.children.map(function (child) {
@@ -6706,15 +6744,9 @@ function () {
 var mathMLTree_TextNode =
 /*#__PURE__*/
 function () {
-  function TextNode(text, needsEscape) {
-    if (needsEscape === void 0) {
-      needsEscape = true;
-    }
-
+  function TextNode(text) {
     this.text = void 0;
-    this.needsEscape = void 0;
     this.text = text;
-    this.needsEscape = needsEscape;
   }
   /**
    * Converts the text node into a DOM text node.
@@ -6724,25 +6756,25 @@ function () {
   var _proto2 = TextNode.prototype;
 
   _proto2.toNode = function toNode() {
-    return document.createTextNode(this.toText());
-  };
+    return document.createTextNode(this.text);
+  }
   /**
    * Converts the text node into escaped HTML markup
    * (representing the text itself).
    */
-
+  ;
 
   _proto2.toMarkup = function toMarkup() {
-    return this.toText();
-  };
+    return utils.escape(this.toText());
+  }
   /**
-   * Converts the text node into an escaped string
+   * Converts the text node into a string
    * (representing the text iteself).
    */
-
+  ;
 
   _proto2.toText = function toText() {
-    return this.needsEscape ? utils.escape(this.text) : this.text;
+    return this.text;
   };
 
   return TextNode;
@@ -6762,26 +6794,26 @@ function () {
     this.width = void 0;
     this.character = void 0;
     this.width = width; // See https://www.w3.org/TR/2000/WD-MathML2-20000328/chapter6.html
-    // for a table of space-like characters.  We consistently use the
-    // &LongNames; because Unicode does not have single characters for
-    // &ThickSpace; (\u2005\u200a) and all negative spaces.
+    // for a table of space-like characters.  We use Unicode
+    // representations instead of &LongNames; as it's not clear how to
+    // make the latter via document.createTextNode.
 
     if (width >= 0.05555 && width <= 0.05556) {
-      this.character = "&VeryThinSpace;"; // \u200a
+      this.character = "\u200A"; // &VeryThinSpace;
     } else if (width >= 0.1666 && width <= 0.1667) {
-      this.character = "&ThinSpace;"; // \u2009
+      this.character = "\u2009"; // &ThinSpace;
     } else if (width >= 0.2222 && width <= 0.2223) {
-      this.character = "&MediumSpace;"; // \u2005
+      this.character = "\u2005"; // &MediumSpace;
     } else if (width >= 0.2777 && width <= 0.2778) {
-      this.character = "&ThickSpace;"; // \u2005\u200a
+      this.character = "\u2005\u200A"; // &ThickSpace;
     } else if (width >= -0.05556 && width <= -0.05555) {
-      this.character = "&NegativeVeryThinSpace;";
+      this.character = "\u200A\u2063"; // &NegativeVeryThinSpace;
     } else if (width >= -0.1667 && width <= -0.1666) {
-      this.character = "&NegativeThinSpace;";
+      this.character = "\u2009\u2063"; // &NegativeThinSpace;
     } else if (width >= -0.2223 && width <= -0.2222) {
-      this.character = "&NegativeMediumSpace;";
+      this.character = "\u205F\u2063"; // &NegativeMediumSpace;
     } else if (width >= -0.2778 && width <= -0.2777) {
-      this.character = "&NegativeThickSpace;";
+      this.character = "\u2005\u2063"; // &NegativeThickSpace;
     } else {
       this.character = null;
     }
@@ -6801,11 +6833,11 @@ function () {
       node.setAttribute("width", this.width + "em");
       return node;
     }
-  };
+  }
   /**
    * Converts the math node into an HTML markup string.
    */
-
+  ;
 
   _proto3.toMarkup = function toMarkup() {
     if (this.character) {
@@ -6813,11 +6845,11 @@ function () {
     } else {
       return "<mspace width=\"" + this.width + "em\"/>";
     }
-  };
+  }
   /**
    * Converts the math node into a string, similar to innerText.
    */
-
+  ;
 
   _proto3.toText = function toText() {
     if (this.character) {
@@ -7055,28 +7087,36 @@ var buildTree_optionsFromSettings = function optionsFromSettings(settings) {
   });
 };
 
+var buildTree_displayWrap = function displayWrap(node, settings) {
+  if (settings.displayMode) {
+    var classes = ["katex-display"];
+
+    if (settings.leqno) {
+      classes.push("leqno");
+    }
+
+    if (settings.fleqn) {
+      classes.push("fleqn");
+    }
+
+    node = buildCommon.makeSpan(classes, [node]);
+  }
+
+  return node;
+};
+
 var buildTree_buildTree = function buildTree(tree, expression, settings) {
   var options = buildTree_optionsFromSettings(settings);
   var mathMLNode = buildMathML(tree, expression, options);
   var htmlNode = buildHTML(tree, options);
   var katexNode = buildCommon.makeSpan(["katex"], [mathMLNode, htmlNode]);
-
-  if (settings.displayMode) {
-    return buildCommon.makeSpan(["katex-display"], [katexNode]);
-  } else {
-    return katexNode;
-  }
+  return buildTree_displayWrap(katexNode, settings);
 };
 var buildTree_buildHTMLTree = function buildHTMLTree(tree, expression, settings) {
   var options = buildTree_optionsFromSettings(settings);
   var htmlNode = buildHTML(tree, options);
   var katexNode = buildCommon.makeSpan(["katex"], [htmlNode]);
-
-  if (settings.displayMode) {
-    return buildCommon.makeSpan(["katex-display"], [katexNode]);
-  } else {
-    return katexNode;
-  }
+  return buildTree_displayWrap(katexNode, settings);
 };
 /* harmony default export */ var src_buildTree = (buildTree_buildTree);
 // CONCATENATED MODULE: ./src/stretchy.js
@@ -8867,7 +8907,7 @@ defineFunction({
   htmlBuilder: function htmlBuilder(group, options) {
     assertParsed(group); // Build the inner expression
 
-    var inner = buildHTML_buildExpression(group.body, options, true, [null, "mclose"]);
+    var inner = buildHTML_buildExpression(group.body, options, true, ["mopen", "mclose"]);
     var innerHeight = 0;
     var innerDepth = 0;
     var hadMiddle = false; // Calculate its height and depth
@@ -10221,7 +10261,6 @@ defineFunction({
         funcName = _ref3.funcName,
         breakOnTokenText = _ref3.breakOnTokenText;
     var mode = parser.mode;
-    parser.consumeSpaces();
     var body = parser.parseExpression(true, breakOnTokenText);
     var style = "math" + funcName.slice(1);
     return {
@@ -10609,24 +10648,20 @@ defineFunction({
     var numer = args[4];
     var denom = args[5]; // Look into the parse nodes to get the desired delimiters.
 
-    var leftNode = checkNodeType(args[0], "ordgroup");
+    var leftNode = checkNodeType(args[0], "atom");
 
     if (leftNode) {
-      leftNode = assertAtomFamily(leftNode.body[0], "open");
-    } else {
       leftNode = assertAtomFamily(args[0], "open");
     }
 
-    var leftDelim = delimFromValue(leftNode.text);
-    var rightNode = checkNodeType(args[1], "ordgroup");
+    var leftDelim = leftNode ? delimFromValue(leftNode.text) : null;
+    var rightNode = checkNodeType(args[1], "atom");
 
     if (rightNode) {
-      rightNode = assertAtomFamily(rightNode.body[0], "close");
-    } else {
       rightNode = assertAtomFamily(args[1], "close");
     }
 
-    var rightDelim = delimFromValue(rightNode.text);
+    var rightDelim = rightNode ? delimFromValue(rightNode.text) : null;
     var barNode = assertNodeType(args[2], "size");
     var hasBarLine;
     var barSize = null;
@@ -11479,7 +11514,7 @@ var singleCharBigOps = {
   "\u22C0": "\\bigwedge",
   "\u22C1": "\\bigvee",
   "\u22C2": "\\bigcap",
-  "\u22C3": "\\bigcap",
+  "\u22C3": "\\bigcup",
   "\u2A00": "\\bigodot",
   "\u2A01": "\\bigoplus",
   "\u2A02": "\\bigotimes",
@@ -11717,9 +11752,8 @@ defineFunction({
       // Write a single TextNode instead of multiple nested tags.
       var word = expression.map(function (node) {
         return node.toText();
-      }).join(""); // word has already been escaped by `node.toText()`
-
-      expression = [new mathMLTree.TextNode(word, false)];
+      }).join("");
+      expression = [new mathMLTree.TextNode(word)];
     }
 
     var identifier = new mathMLTree.MathNode("mi", expression);
@@ -11738,6 +11772,10 @@ defineFunction({
 defineFunctionBuilders({
   type: "ordgroup",
   htmlBuilder: function htmlBuilder(group, options) {
+    if (group.semisimple) {
+      return buildCommon.makeFragment(buildHTML_buildExpression(group.body, options, false));
+    }
+
     return buildCommon.makeSpan(["mord"], buildHTML_buildExpression(group.body, options, true), options);
   },
   mathmlBuilder: function mathmlBuilder(group, options) {
@@ -11866,8 +11904,9 @@ defineFunction({
         type: "elem",
         elem: node
       }]
-    }, options);
-    return node;
+    }, options); // For spacing, TeX treats \smash as a math group (same spacing as ord).
+
+    return buildCommon.makeSpan(["mord"], [node], options);
   },
   mathmlBuilder: function mathmlBuilder(group, options) {
     var inner = buildMathML_buildExpression(defineFunction_ordargument(group.body), options);
@@ -11952,7 +11991,6 @@ defineFunction({
     var breakOnTokenText = _ref.breakOnTokenText,
         funcName = _ref.funcName,
         parser = _ref.parser;
-    parser.consumeSpaces();
     var body = parser.parseExpression(false, breakOnTokenText);
     return {
       type: "sizing",
@@ -12155,7 +12193,7 @@ defineFunction({
     };
   },
   htmlBuilder: function htmlBuilder(group, options) {
-    var node = buildCommon.makeSpan(["mord"], [buildHTML_buildGroup(group.body, options)]);
+    var node = buildCommon.makeSpan([], [buildHTML_buildGroup(group.body, options)]);
 
     if (!group.smashHeight && !group.smashDepth) {
       return node;
@@ -12185,13 +12223,15 @@ defineFunction({
     // from acting on that line height. So we'll call makeVList now.
 
 
-    return buildCommon.makeVList({
+    var smashedNode = buildCommon.makeVList({
       positionType: "firstBaseline",
       children: [{
         type: "elem",
         elem: node
       }]
-    }, options);
+    }, options); // For spacing, TeX treats \hphantom as a math group (same spacing as ord).
+
+    return buildCommon.makeSpan(["mord"], [smashedNode], options);
   },
   mathmlBuilder: function mathmlBuilder(group, options) {
     var node = new mathMLTree.MathNode("mpadded", [buildMathML_buildGroup(group.body, options)]);
@@ -12348,7 +12388,6 @@ defineFunction({
         funcName = _ref.funcName,
         parser = _ref.parser;
     // parse out the implicit body
-    parser.consumeSpaces();
     var body = parser.parseExpression(true, breakOnTokenText); // TODO: Refactor to avoid duplicating styleMap in multiple places (e.g.
     // here and in buildHTML and de-dupe the enumeration of all the styles).
     // $FlowFixMe: The names above exactly match the styles.
@@ -13070,28 +13109,37 @@ combiningDiacriticalMarkString + "*") + // ...plus accents
 "|\\\\verb([^*a-zA-Z]).*?\\4" + ( // \verb unstarred
 "|" + controlWordWhitespaceRegexString) + ( // \macroName + spaces
 "|" + controlSymbolRegexString + ")"); // \\, \', etc.
-// These regexs are for matching results from tokenRegex,
-// so they do have ^ markers.
 
-var controlWordRegex = new RegExp("^" + controlWordRegexString);
 /** Main Lexer class */
 
 var Lexer_Lexer =
 /*#__PURE__*/
 function () {
-  function Lexer(input) {
+  // category codes, only supports comment characters (14) for now
+  function Lexer(input, settings) {
     this.input = void 0;
+    this.settings = void 0;
     this.tokenRegex = void 0;
+    this.catcodes = void 0;
     // Separate accents from characters
     this.input = input;
+    this.settings = settings;
     this.tokenRegex = new RegExp(tokenRegexString, 'g');
+    this.catcodes = {
+      "%": 14 // comment character
+
+    };
+  }
+
+  var _proto = Lexer.prototype;
+
+  _proto.setCatcode = function setCatcode(char, code) {
+    this.catcodes[char] = code;
   }
   /**
    * This function lexes a single token.
    */
-
-
-  var _proto = Lexer.prototype;
+  ;
 
   _proto.lex = function lex() {
     var input = this.input;
@@ -13107,7 +13155,23 @@ function () {
       throw new src_ParseError("Unexpected character: '" + input[pos] + "'", new Token_Token(input[pos], new SourceLocation(this, pos, pos + 1)));
     }
 
-    var text = match[2] || " "; // Trim any trailing whitespace from control word match
+    var text = match[2] || " ";
+
+    if (this.catcodes[text] === 14) {
+      // comment character
+      var nlIndex = input.indexOf('\n', this.tokenRegex.lastIndex);
+
+      if (nlIndex === -1) {
+        this.tokenRegex.lastIndex = input.length; // EOF
+
+        this.settings.reportNonstrict("commentAtEnd", "% comment has no terminating newline; LaTeX would " + "fail because of commenting the end of math mode (e.g. $)");
+      } else {
+        this.tokenRegex.lastIndex = nlIndex + 1;
+      }
+
+      return this.lex();
+    } // Trim any trailing whitespace from control word match
+
 
     var controlMatch = text.match(controlWordWhitespaceRegex);
 
@@ -13166,11 +13230,11 @@ function () {
 
   _proto.beginGroup = function beginGroup() {
     this.undefStack.push({});
-  };
+  }
   /**
    * End current nested group, restoring values before the group began.
    */
-
+  ;
 
   _proto.endGroup = function endGroup() {
     if (this.undefStack.length === 0) {
@@ -13188,16 +13252,16 @@ function () {
         }
       }
     }
-  };
+  }
   /**
    * Detect whether `name` has a definition.  Equivalent to
    * `get(name) != null`.
    */
-
+  ;
 
   _proto.has = function has(name) {
     return this.current.hasOwnProperty(name) || this.builtins.hasOwnProperty(name);
-  };
+  }
   /**
    * Get the current value of a name, or `undefined` if there is no value.
    *
@@ -13206,7 +13270,7 @@ function () {
    * to `false` in JavaScript.  Use `if (namespace.get(...) != null)` or
    * `if (namespace.has(...))`.
    */
-
+  ;
 
   _proto.get = function get(name) {
     if (this.current.hasOwnProperty(name)) {
@@ -13214,14 +13278,14 @@ function () {
     } else {
       return this.builtins[name];
     }
-  };
+  }
   /**
    * Set the current value of a name, and optionally set it globally too.
    * Local set() sets the current value and (when appropriate) adds an undo
    * operation to the undo stack.  Global set() may change the undo
    * operation at every level, so takes time linear in their number.
    */
-
+  ;
 
   _proto.set = function set(name, value, global) {
     if (global === void 0) {
@@ -13544,9 +13608,7 @@ defineMacro("\\providecommand", function (context) {
 // \let\bgroup={ \let\egroup=}
 
 defineMacro("\\bgroup", "{");
-defineMacro("\\egroup", "}");
-defineMacro("\\begingroup", "{");
-defineMacro("\\endgroup", "}"); // Symbols from latex.ltx:
+defineMacro("\\egroup", "}"); // Symbols from latex.ltx:
 // \def\lq{`}
 // \def\rq{'}
 // \def \aa {\r a}
@@ -13564,17 +13626,7 @@ defineMacro("\\AA", "\\r A"); // Copyright (C) and registered (R) symbols. Use r
 
 defineMacro("\\textcopyright", "\\html@mathml{\\textcircled{c}}{\\char`©}");
 defineMacro("\\copyright", "\\TextOrMath{\\textcopyright}{\\text{\\textcopyright}}");
-defineMacro("\\textregistered", "\\html@mathml{\\textcircled{\\scriptsize R}}{\\char`®}"); // Unicode double-struck letters
-
-defineMacro("\u2102", "\\mathbb{C}");
-defineMacro("\u210D", "\\mathbb{H}");
-defineMacro("\u2115", "\\mathbb{N}");
-defineMacro("\u2119", "\\mathbb{P}");
-defineMacro("\u211A", "\\mathbb{Q}");
-defineMacro("\u211D", "\\mathbb{R}");
-defineMacro("\u2124", "\\mathbb{Z}");
-defineMacro("\u210E", "\\mathit{h}"); // Planck constant
-// Characters omitted from Unicode range 1D400–1D7FF
+defineMacro("\\textregistered", "\\html@mathml{\\textcircled{\\scriptsize R}}{\\char`®}"); // Characters omitted from Unicode range 1D400–1D7FF
 
 defineMacro("\u212C", "\\mathscr{B}"); // script
 
@@ -14054,7 +14106,12 @@ defineMacro("\\Tau", "\\mathrm{T}");
 defineMacro("\\thetasym", "\\vartheta"); // TODO: defineMacro("\\varcoppa", "\\\mbox{\\coppa}");
 
 defineMacro("\\weierp", "\\wp");
-defineMacro("\\Zeta", "\\mathrm{Z}");
+defineMacro("\\Zeta", "\\mathrm{Z}"); //////////////////////////////////////////////////////////////////////
+// statmath.sty
+// https://ctan.math.illinois.edu/macros/latex/contrib/statmath/statmath.pdf
+
+defineMacro("\\argmin", "\\DOTSB\\mathop{\\operatorname{arg\\,min}}\\limits");
+defineMacro("\\argmax", "\\DOTSB\\mathop{\\operatorname{arg\\,max}}\\limits");
 // CONCATENATED MODULE: ./src/MacroExpander.js
 /**
  * This file contains the “gullet” where macros are expanded
@@ -14109,37 +14166,37 @@ function () {
   var _proto = MacroExpander.prototype;
 
   _proto.feed = function feed(input) {
-    this.lexer = new Lexer_Lexer(input);
-  };
+    this.lexer = new Lexer_Lexer(input, this.settings);
+  }
   /**
    * Switches between "text" and "math" modes.
    */
-
+  ;
 
   _proto.switchMode = function switchMode(newMode) {
     this.mode = newMode;
-  };
+  }
   /**
    * Start a new group nesting within all namespaces.
    */
-
+  ;
 
   _proto.beginGroup = function beginGroup() {
     this.macros.beginGroup();
-  };
+  }
   /**
    * End current group nesting within all namespaces.
    */
-
+  ;
 
   _proto.endGroup = function endGroup() {
     this.macros.endGroup();
-  };
+  }
   /**
    * Returns the topmost token on the stack, without expanding it.
    * Similar in behavior to TeX's `\futurelet`.
    */
-
+  ;
 
   _proto.future = function future() {
     if (this.stack.length === 0) {
@@ -14147,40 +14204,40 @@ function () {
     }
 
     return this.stack[this.stack.length - 1];
-  };
+  }
   /**
    * Remove and return the next unexpanded token.
    */
-
+  ;
 
   _proto.popToken = function popToken() {
     this.future(); // ensure non-empty stack
 
     return this.stack.pop();
-  };
+  }
   /**
    * Add a given token to the token stack.  In particular, this get be used
    * to put back a token returned from one of the other methods.
    */
-
+  ;
 
   _proto.pushToken = function pushToken(token) {
     this.stack.push(token);
-  };
+  }
   /**
    * Append an array of tokens to the token stack.
    */
-
+  ;
 
   _proto.pushTokens = function pushTokens(tokens) {
     var _this$stack;
 
     (_this$stack = this.stack).push.apply(_this$stack, tokens);
-  };
+  }
   /**
    * Consume all following space tokens, without expansion.
    */
-
+  ;
 
   _proto.consumeSpaces = function consumeSpaces() {
     for (;;) {
@@ -14192,12 +14249,12 @@ function () {
         break;
       }
     }
-  };
+  }
   /**
    * Consume the specified number of arguments from the token stream,
    * and return the resulting array of arguments.
    */
-
+  ;
 
   _proto.consumeArgs = function consumeArgs(numArgs) {
     var args = []; // obtain arguments, either single token or balanced {…} group
@@ -14237,7 +14294,7 @@ function () {
     }
 
     return args;
-  };
+  }
   /**
    * Expand the next token only once if possible.
    *
@@ -14258,7 +14315,7 @@ function () {
    * i.e. things like those defined by \def\foo#1\end{…}.
    * See the TeX book page 202ff. for details on how those should behave.
    */
-
+  ;
 
   _proto.expandOnce = function expandOnce() {
     var topToken = this.popToken();
@@ -14314,23 +14371,23 @@ function () {
 
     this.pushTokens(tokens);
     return tokens;
-  };
+  }
   /**
    * Expand the next token only once (if possible), and return the resulting
    * top token on the stack (without removing anything from the stack).
    * Similar in behavior to TeX's `\expandafter\futurelet`.
    * Equivalent to expandOnce() followed by future().
    */
-
+  ;
 
   _proto.expandAfterFuture = function expandAfterFuture() {
     this.expandOnce();
     return this.future();
-  };
+  }
   /**
    * Recursively expand first token, then return first non-expandable token.
    */
-
+  ;
 
   _proto.expandNextToken = function expandNextToken() {
     for (;;) {
@@ -14350,12 +14407,12 @@ function () {
 
 
     throw new Error(); // eslint-disable-line no-unreachable
-  };
+  }
   /**
    * Fully expand the given macro name and return the resulting list of
    * tokens, or return `undefined` if no such macro is defined.
    */
-
+  ;
 
   _proto.expandMacro = function expandMacro(name) {
     if (!this.macros.get(name)) {
@@ -14375,12 +14432,12 @@ function () {
     }
 
     return output;
-  };
+  }
   /**
    * Fully expand the given macro name and return the result as a string,
    * or return `undefined` if no such macro is defined.
    */
-
+  ;
 
   _proto.expandMacroAsText = function expandMacroAsText(name) {
     var tokens = this.expandMacro(name);
@@ -14392,12 +14449,12 @@ function () {
     } else {
       return tokens;
     }
-  };
+  }
   /**
    * Returns the expanded macro as a reversed array of tokens and a macro
    * argument count.  Or returns `null` if no such macro.
    */
-
+  ;
 
   _proto._getExpansion = function _getExpansion(name) {
     var definition = this.macros.get(name);
@@ -14420,7 +14477,7 @@ function () {
         }
       }
 
-      var bodyLexer = new Lexer_Lexer(expansion);
+      var bodyLexer = new Lexer_Lexer(expansion, this.settings);
       var tokens = [];
       var tok = bodyLexer.lex();
 
@@ -14439,14 +14496,14 @@ function () {
     }
 
     return expansion;
-  };
+  }
   /**
    * Determine whether a command is currently "defined" (has some
    * functionality), meaning that it's a macro (in the current group),
    * a function, a symbol, or one of the special commands listed in
    * `implicitCommands`.
    */
-
+  ;
 
   _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);
@@ -15229,29 +15286,29 @@ function () {
     if (consume) {
       this.consume();
     }
-  };
+  }
   /**
    * Considers the current look ahead token as consumed,
    * and fetches the one after that as the new look ahead.
    */
-
+  ;
 
   _proto.consume = function consume() {
     this.nextToken = this.gullet.expandNextToken();
-  };
+  }
   /**
    * Switches between "text" and "math" modes.
    */
-
+  ;
 
   _proto.switchMode = function switchMode(newMode) {
     this.mode = newMode;
     this.gullet.switchMode(newMode);
-  };
+  }
   /**
    * Main parsing function, which parses an entire input.
    */
-
+  ;
 
   _proto.parse = function parse() {
     // Create a group namespace for the math expression.
@@ -15274,17 +15331,6 @@ function () {
     return parse;
   };
 
-  /**
-   * Parses an "expression", which is a list of atoms.
-   *
-   * `breakOnInfix`: Should the parsing stop when we hit infix nodes? This
-   *                 happens when functions have higher precendence han infix
-   *                 nodes in implicit parses.
-   *
-   * `breakOnTokenText`: The text of the token that the expression should end
-   *                     with, or `null` if something else should end the
-   *                     expression.
-   */
   _proto.parseExpression = function parseExpression(breakOnInfix, breakOnTokenText) {
     var body = []; // Keep adding atoms to the body until we can't parse any more atoms (either
     // we reached the end, a }, or a \right)
@@ -15323,7 +15369,7 @@ function () {
     }
 
     return this.handleInfixNodes(body);
-  };
+  }
   /**
    * Rewrites infix operators such as \over with corresponding commands such
    * as \frac.
@@ -15331,7 +15377,7 @@ function () {
    * There can only be one infix operator per group.  If there's more than one
    * then the expression is ambiguous.  This can be resolved by adding {}.
    */
-
+  ;
 
   _proto.handleInfixNodes = function handleInfixNodes(body) {
     var overIndex = -1;
@@ -15388,8 +15434,8 @@ function () {
     } else {
       return body;
     }
-  }; // The greediness of a superscript or subscript
-
+  } // The greediness of a superscript or subscript
+  ;
 
   /**
    * Handle a subscript or superscript with nice errors.
@@ -15407,12 +15453,12 @@ function () {
     }
 
     return group;
-  };
+  }
   /**
    * Converts the textual input of an unsupported command into a text node
    * contained within a color node whose color is determined by errorColor
    */
-
+  ;
 
   _proto.handleUnsupportedCmd = function handleUnsupportedCmd() {
     var text = this.nextToken.text;
@@ -15439,11 +15485,11 @@ function () {
     };
     this.consume();
     return colorNode;
-  };
+  }
   /**
    * Parses a group with optional super/subscripts.
    */
-
+  ;
 
   _proto.parseAtom = function parseAtom(breakOnTokenText) {
     // The body of an atom is an implicit group, so that things like
@@ -15524,8 +15570,6 @@ function () {
           mode: this.mode,
           body: primes
         };
-      } else if (lex.text === "%") {
-        this.consumeComment();
       } else {
         // If it wasn't ^, _, or ', stop parsing super/subscripts
         break;
@@ -15547,11 +15591,11 @@ function () {
       // Otherwise return the original body
       return base;
     }
-  };
+  }
   /**
    * Parses an entire function, including its base and all of its arguments.
    */
-
+  ;
 
   _proto.parseFunction = function parseFunction(breakOnTokenText, name, // For error reporting.
   greediness) {
@@ -15569,6 +15613,11 @@ function () {
       throw new src_ParseError("Can't use function '" + func + "' in text mode", token);
     } else if (this.mode === "math" && funcData.allowedInMath === false) {
       throw new src_ParseError("Can't use function '" + func + "' in math mode", token);
+    } // hyperref package sets the catcode of % as an active character
+
+
+    if (funcData.argTypes && funcData.argTypes[0] === "url") {
+      this.gullet.lexer.setCatcode("%", 13);
     } // Consume the command token after possibly switching to the
     // mode specified by the function (for instant mode switching),
     // and then immediately switch back.
@@ -15588,11 +15637,11 @@ function () {
         optArgs = _this$parseArguments.optArgs;
 
     return this.callFunction(func, args, optArgs, token, breakOnTokenText);
-  };
+  }
   /**
    * Call a function handler with a suitable context and arguments.
    */
-
+  ;
 
   _proto.callFunction = function callFunction(name, args, optArgs, token, breakOnTokenText) {
     var context = {
@@ -15608,11 +15657,11 @@ function () {
     } else {
       throw new src_ParseError("No function handler for " + name);
     }
-  };
+  }
   /**
    * Parses the arguments of a function or environment
    */
-
+  ;
 
   _proto.parseArguments = function parseArguments(func, // Should look like "\name" or "\begin{name}".
   funcData) {
@@ -15669,11 +15718,11 @@ function () {
       args: args,
       optArgs: optArgs
     };
-  };
+  }
   /**
    * Parses a group when the mode is changing.
    */
-
+  ;
 
   _proto.parseGroupOfType = function parseGroupOfType(name, type, optional, greediness) {
     switch (type) {
@@ -15690,6 +15739,25 @@ function () {
       case "text":
         return this.parseGroup(name, optional, greediness, undefined, type);
 
+      case "raw":
+        {
+          if (optional && this.nextToken.text === "{") {
+            return null;
+          }
+
+          var token = this.parseStringGroup("raw", optional, true);
+
+          if (token) {
+            return {
+              type: "raw",
+              mode: "text",
+              string: token.text
+            };
+          } else {
+            throw new src_ParseError("Expected raw group", this.nextToken);
+          }
+        }
+
       case "original":
       case null:
       case undefined:
@@ -15704,34 +15772,12 @@ function () {
     while (this.nextToken.text === " ") {
       this.consume();
     }
-  };
-
-  _proto.consumeComment = function consumeComment() {
-    // the newline character is normalized in Lexer, check original source
-    while (this.nextToken.text !== "EOF" && this.nextToken.loc && this.nextToken.loc.getSource().indexOf("\n") === -1) {
-      this.consume();
-    }
-
-    if (this.nextToken.text === "EOF") {
-      this.settings.reportNonstrict("commentAtEnd", "% comment has no terminating newline; LaTeX would " + "fail because of commenting the end of math mode (e.g. $)");
-    }
-
-    if (this.mode === "math") {
-      this.consumeSpaces(); // ignore spaces in math mode
-    } else if (this.nextToken.loc) {
-      // text mode
-      var source = this.nextToken.loc.getSource();
-
-      if (source.indexOf("\n") === source.length - 1) {
-        this.consumeSpaces(); // if no space after the first newline
-      }
-    }
-  };
+  }
   /**
    * Parses a group, essentially returning the string formed by the
    * brace-enclosed tokens plus some position information.
    */
-
+  ;
 
   _proto.parseStringGroup = function parseStringGroup(modeName, // Used to describe the mode in error messages.
   optional, raw) {
@@ -15744,6 +15790,8 @@ function () {
         return null;
       } else if (raw && nextToken.text !== "EOF" && /[^{}[\]]/.test(nextToken.text)) {
         // allow a single character in raw string group
+        this.gullet.lexer.setCatcode("%", 14); // reset the catcode of %
+
         this.consume();
         return nextToken;
       }
@@ -15763,15 +15811,6 @@ function () {
         case "EOF":
           throw new src_ParseError("Unexpected end of input in " + modeName, firstToken.range(lastToken, str));
 
-        case "%":
-          if (!raw) {
-            // allow % in raw string group
-            this.consumeComment();
-            continue;
-          }
-
-          break;
-
         case groupBegin:
           nested++;
           break;
@@ -15787,15 +15826,17 @@ function () {
     }
 
     this.mode = outerMode;
+    this.gullet.lexer.setCatcode("%", 14); // reset the catcode of %
+
     this.expect(groupEnd);
     return firstToken.range(lastToken, str);
-  };
+  }
   /**
    * Parses a regex-delimited group: the largest sequence of tokens
    * whose concatenated strings match `regex`. Returns the string
    * formed by the tokens plus some position information.
    */
-
+  ;
 
   _proto.parseRegexGroup = function parseRegexGroup(regex, modeName) {
     var outerMode = this.mode;
@@ -15804,12 +15845,7 @@ function () {
     var lastToken = firstToken;
     var str = "";
 
-    while (this.nextToken.text !== "EOF" && (regex.test(str + this.nextToken.text) || this.nextToken.text === "%")) {
-      if (this.nextToken.text === "%") {
-        this.consumeComment();
-        continue;
-      }
-
+    while (this.nextToken.text !== "EOF" && regex.test(str + this.nextToken.text)) {
       lastToken = this.nextToken;
       str += lastToken.text;
       this.consume();
@@ -15821,11 +15857,11 @@ function () {
 
     this.mode = outerMode;
     return firstToken.range(lastToken, str);
-  };
+  }
   /**
    * Parses a color description.
    */
-
+  ;
 
   _proto.parseColorGroup = function parseColorGroup(optional) {
     var res = this.parseStringGroup("color", optional);
@@ -15854,11 +15890,11 @@ function () {
       mode: this.mode,
       color: color
     };
-  };
+  }
   /**
    * Parses a size specification, consisting of magnitude and unit.
    */
-
+  ;
 
   _proto.parseSizeGroup = function parseSizeGroup(optional) {
     var res;
@@ -15905,11 +15941,11 @@ function () {
       value: data,
       isBlank: isBlank
     };
-  };
+  }
   /**
    * Parses an URL, checking escaped letters and allowed protocols.
    */
-
+  ;
 
   _proto.parseUrlGroup = function parseUrlGroup(optional) {
     var res = this.parseStringGroup("url", optional, true); // get raw string
@@ -15936,7 +15972,7 @@ function () {
       mode: this.mode,
       url: url
     };
-  };
+  }
   /**
    * If `optional` is false or absent, this parses an ordinary group,
    * which is either a single nucleus (like "x") or an expression
@@ -15949,7 +15985,7 @@ function () {
    * If `mode` is present, switches to that mode while parsing the group,
    * and switches back after.
    */
-
+  ;
 
   _proto.parseGroup = function parseGroup(name, // For error reporting.
   optional, greediness, breakOnTokenText, mode) {
@@ -15961,29 +15997,29 @@ function () {
       this.switchMode(mode);
     }
 
-    var result; // Try to parse an open brace
+    var groupEnd;
+    var result; // Try to parse an open brace or \begingroup
+
+    if (optional ? text === "[" : text === "{" || text === "\\begingroup") {
+      groupEnd = Parser.endOfGroup[text]; // Start a new group namespace
 
-    if (text === (optional ? "[" : "{")) {
-      // Start a new group namespace
       this.gullet.beginGroup(); // If we get a brace, parse an expression
 
       this.consume();
-      var expression = this.parseExpression(false, optional ? "]" : "}");
-      var lastToken = this.nextToken; // Switch mode back before consuming symbol after close brace
-
-      if (mode) {
-        this.switchMode(outerMode);
-      } // End group namespace before consuming symbol after close brace
+      var expression = this.parseExpression(false, groupEnd);
+      var lastToken = this.nextToken; // End group namespace before consuming symbol after close brace
 
-
-      this.gullet.endGroup(); // Make sure we get a close brace
-
-      this.expect(optional ? "]" : "}");
-      return {
+      this.gullet.endGroup();
+      result = {
         type: "ordgroup",
         mode: this.mode,
         loc: SourceLocation.range(firstToken, lastToken),
-        body: expression
+        body: expression,
+        // A group formed by \begingroup...\endgroup is a semi-simple group
+        // which doesn't affect spacing in math mode, i.e., is transparent.
+        // https://tex.stackexchange.com/questions/1930/when-should-one-
+        // use-begingroup-instead-of-bgroup
+        semisimple: text === "\\begingroup" || undefined
       };
     } else if (optional) {
       // Return nothing for an optional group
@@ -16005,10 +16041,15 @@ function () {
 
     if (mode) {
       this.switchMode(outerMode);
+    } // Make sure we got a close brace
+
+
+    if (groupEnd) {
+      this.expect(groupEnd);
     }
 
     return result;
-  };
+  }
   /**
    * Form ligature-like combinations of characters for text mode.
    * This includes inputs like "--", "---", "``" and "''".
@@ -16017,7 +16058,7 @@ function () {
    * characters in its value.  The representation is still ASCII source.
    * The group will be modified in place.
    */
-
+  ;
 
   _proto.formLigatures = function formLigatures(group) {
     var n = group.length - 1;
@@ -16057,12 +16098,12 @@ function () {
         n -= 1;
       }
     }
-  };
+  }
   /**
    * Parse a single symbol out of the string. Here, we handle single character
    * symbols and special functions like verbatim
    */
-
+  ;
 
   _proto.parseSymbol = function parseSymbol() {
     var nucleus = this.nextToken;
@@ -16091,9 +16132,6 @@ function () {
         body: arg,
         star: star
       };
-    } else if (text === "%") {
-      this.consumeComment();
-      return this.parseSymbol();
     } // At this point, we should have a symbol, possibly with accents.
     // First expand any accented base symbol according to unicodeSymbols.
 
@@ -16207,7 +16245,24 @@ function () {
   return Parser;
 }();
 
-Parser_Parser.endOfExpression = ["}", "\\end", "\\right", "&"];
+Parser_Parser.endOfExpression = ["}", "\\endgroup", "\\end", "\\right", "&"];
+Parser_Parser.endOfGroup = {
+  "[": "]",
+  "{": "}",
+  "\\begingroup": "\\endgroup"
+  /**
+   * Parses an "expression", which is a list of atoms.
+   *
+   * `breakOnInfix`: Should the parsing stop when we hit infix nodes? This
+   *                 happens when functions have higher precendence han infix
+   *                 nodes in implicit parses.
+   *
+   * `breakOnTokenText`: The text of the token that the expression should end
+   *                     with, or `null` if something else should end the
+   *                     expression.
+   */
+
+};
 Parser_Parser.SUPSUB_GREEDINESS = 1;
 
 // CONCATENATED MODULE: ./src/parseTree.js
@@ -16363,7 +16418,7 @@ var katex_renderToHTMLTree = function renderToHTMLTree(expression, options) {
   /**
    * Current KaTeX version
    */
-  version: "0.10.0",
+  version: "0.10.1",
 
   /**
    * Renders the given LaTeX into an HTML+MathML combination, and adds
@@ -16446,8 +16501,9 @@ var katex_renderToHTMLTree = function renderToHTMLTree(expression, options) {
 });
 // CONCATENATED MODULE: ./katex.webpack.js
 /**
- * This is the webpack entry point for KaTeX. As flow[1] and jest[2] doesn't support
- * CSS modules natively, a separate entry point is used and it is not flowtyped.
+ * This is the webpack entry point for KaTeX. As ECMAScript, flow[1] and jest[2]
+ * doesn't support CSS modules natively, a separate entry point is used and
+ * it is not flowtyped.
  *
  * [1] https://gist.github.com/lambdahands/d19e0da96285b749f0ef
  * [2] https://facebook.github.io/jest/docs/en/webpack.html