katex 0.16.47 → 0.18.0

package/dist/katex.js

@@ -1008,6 +1008,7 @@ const relativeUnit = {
   "em": true,
   "mu": true
 };
+
 /**
  * Determine whether the specified unit (either a string defining the unit
  * or a "size" parse node containing a unit field) is valid.
@@ -3904,10 +3905,8 @@ function getGlobalMetrics(size) {
     const metrics = fontMetricsBySizeIndex[sizeIndex] = {
       cssEmPerMu: sigmasAndXis.quad[sizeIndex] / 18
     };
-    for (const key in sigmasAndXis) {
-      if (sigmasAndXis.hasOwnProperty(key)) {
-        metrics[key] = sigmasAndXis[key][sizeIndex];
-      }
+    for (const key of Object.keys(sigmasAndXis)) {
+      metrics[key] = sigmasAndXis[key][sizeIndex];
     }
   }
   return fontMetricsBySizeIndex[sizeIndex];
@@ -5027,16 +5026,16 @@ const boldSymbol = function (value, mode, type) {
 /**
  * Makes either a mathord or textord in the correct font and color.
  */
-const makeOrd = function (group, options, type) {
+const makeOrd = function (group, options) {
+  // Spacing nodes are rendered as textord.
+  const type = group.type === "mathord" ? "mathord" : "textord";
   const mode = group.mode;
   const text = group.text;
   const classes = ["mord"];
-  const {
-    font,
-    fontFamily,
-    fontWeight,
-    fontShape
-  } = options;
+  const font = options.font,
+    fontFamily = options.fontFamily,
+    fontWeight = options.fontWeight,
+    fontShape = options.fontShape;
 
   // Math mode or Old font (i.e. \rm)
   const useFont = mode === "math" || mode === "text" && !!font;
@@ -5067,7 +5066,7 @@ const makeOrd = function (group, options, type) {
     }
     if (lookupSymbol(text, fontName, mode).metrics) {
       return makeSymbol(text, fontName, mode, options, classes.concat(fontClasses));
-    } else if (ligatures.hasOwnProperty(text) && fontName.slice(0, 10) === "Typewriter") {
+    } else if (Object.prototype.hasOwnProperty.call(ligatures, text) && fontName.slice(0, 10) === "Typewriter") {
       // Deconstruct ligatures in monospace fonts (\texttt, \tt).
       const parts = [];
       for (let i = 0; i < text.length; i++) {
@@ -5302,10 +5301,9 @@ const getVListChildrenAndDepth = function (params) {
  * See VListParam documentation above.
  */
 const makeVList = function (params, options) {
-  const {
-    children,
-    depth
-  } = getVListChildrenAndDepth(params);
+  const _getVListChildrenAndD = getVListChildrenAndDepth(params),
+    children = _getVListChildrenAndD.children,
+    depth = _getVListChildrenAndD.depth;
 
   // Create a strut that is taller than any list item. The strut is added to
   // each item, where it will determine the item's baseline. Since it has
@@ -5506,7 +5504,10 @@ const svgData = {
 };
 const staticSvg = function (value, options) {
   // Create a span with inline SVG for the element.
-  const [pathName, width, height] = svgData[value];
+  const _svgData$value = svgData[value],
+    pathName = _svgData$value[0],
+    width = _svgData$value[1],
+    height = _svgData$value[2];
   const path = new PathNode(pathName);
   const svgNode = new SvgNode([path], {
     "width": makeEm(width),
@@ -5516,7 +5517,7 @@ const staticSvg = function (value, options) {
     "viewBox": "0 0 " + 1000 * width + " " + 1000 * height,
     "preserveAspectRatio": "xMinYMin"
   });
-  const span = makeSvgSpan(["overlay"], [svgNode], options);
+  const span = makeSvgSpan(["katex-overlay"], [svgNode], options);
   span.height = height;
   span.style.height = makeEm(height);
   span.style.width = makeEm(width);
@@ -5630,11 +5631,19 @@ const tightSpacings = {
 // 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.
+ * Parser-facing function spec.  Optional properties should use the defaults
+ * documented below.
+ */
+
+/**
+ * Builder fields consumed during registration.  These are stored separately in
+ * `_htmlGroupBuilders` and `_mathmlGroupBuilders`, and are not used by Parser.
+ */
+
+/**
+ * Full registration spec passed to `defineFunction`.  It combines the
+ * parser-facing fields with optional builder fields and the names being
+ * registered.
  */
 
 /**
@@ -5662,29 +5671,15 @@ const _htmlGroupBuilders = {};
  */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 const _mathmlGroupBuilders = {};
-function defineFunction(_ref) {
-  let {
-    type,
-    names,
-    props,
-    handler,
-    htmlBuilder,
-    mathmlBuilder
-  } = _ref;
-  // Set default values of functions
-  const data = {
-    type,
-    numArgs: props.numArgs,
-    argTypes: props.argTypes,
-    allowedInArgument: !!props.allowedInArgument,
-    allowedInText: !!props.allowedInText,
-    allowedInMath: props.allowedInMath === undefined ? true : props.allowedInMath,
-    numOptionalArgs: props.numOptionalArgs || 0,
-    infix: !!props.infix,
-    primitive: !!props.primitive,
-    handler
-  };
+function defineFunction(data) {
+  const type = data.type,
+    names = data.names,
+    htmlBuilder = data.htmlBuilder,
+    mathmlBuilder = data.mathmlBuilder;
   for (let i = 0; i < names.length; ++i) {
+    // To avoid destructuring and rebuilding an object,
+    // we store the entire FunctionDefSpec object,
+    // even though Parser only needs the FunctionSpec fields.
     _functions[names[i]] = data;
   }
   if (type) {
@@ -5702,24 +5697,16 @@ function defineFunction(_ref) {
  * if the function's ParseNode is generated in Parser.js rather than via a
  * stand-alone handler provided to `defineFunction`).
  */
-function defineFunctionBuilders(_ref2) {
-  let {
-    type,
-    htmlBuilder,
-    mathmlBuilder
-  } = _ref2;
-  defineFunction({
-    type,
-    names: [],
-    props: {
-      numArgs: 0
-    },
-    handler() {
-      throw new Error('Should never be called.');
-    },
-    htmlBuilder,
-    mathmlBuilder
-  });
+function defineFunctionBuilders(_ref) {
+  let type = _ref.type,
+    htmlBuilder = _ref.htmlBuilder,
+    mathmlBuilder = _ref.mathmlBuilder;
+  if (htmlBuilder) {
+    _htmlGroupBuilders[type] = htmlBuilder;
+  }
+  if (mathmlBuilder) {
+    _mathmlGroupBuilders[type] = mathmlBuilder;
+  }
 }
 const normalizeArgument = function (arg) {
   return arg.type === "ordgroup" && arg.body.length === 1 ? arg.body[0] : arg;
@@ -5889,7 +5876,7 @@ const traverseNonSpaceNodes = function (nodes, callback, prev, next, isRoot) {
     }
     if (nonspace) {
       prev.node = node;
-    } else if (isRoot && node.hasClass("newline")) {
+    } else if (isRoot && node.hasClass("katex-newline")) {
       prev.node = makeSpan(["leftmost"]); // treat like beginning of line
     }
     prev.insertAfter = (index => n => {
@@ -5975,18 +5962,18 @@ const buildGroup = function (group, options, baseOptions) {
 
 /**
  * Combine an array of HTML DOM nodes (e.g., the output of `buildExpression`)
- * into an unbreakable HTML node of class .base, with proper struts to
+ * into an unbreakable HTML node of class .katex-base, with proper struts to
  * guarantee correct vertical extent.  `buildHTML` calls this repeatedly to
  * make up the entire expression as a sequence of unbreakable units.
  */
 function buildHTMLUnbreakable(children, options) {
   // Compute height and depth of this chunk.
-  const body = makeSpan(["base"], children, options);
+  const body = makeSpan(["katex-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.
-  const strut = makeSpan(["strut"]);
+  const strut = makeSpan(["katex-strut"]);
   strut.style.height = makeEm(body.height + body.depth);
   if (body.depth) {
     strut.style.verticalAlign = makeEm(-body.depth);
@@ -6010,7 +5997,7 @@ function buildHTML(tree, options) {
   // Build the expression contained in the tree
   const expression = buildExpression(tree, options, "root");
   let eqnNum;
-  if (expression.length === 2 && expression[1].hasClass("tag")) {
+  if (expression.length === 2 && expression[1].hasClass("katex-tag")) {
     // An environment with automatic equation numbers, e.g. {gather}.
     eqnNum = expression.pop();
   }
@@ -6030,7 +6017,7 @@ function buildHTML(tree, options) {
       // Put any post-operator glue on same line as operator.
       // Watch for \nobreak along the way, and stop at \newline.
       let nobreak = false;
-      while (i < expression.length - 1 && expression[i + 1].hasClass("mspace") && !expression[i + 1].hasClass("newline")) {
+      while (i < expression.length - 1 && expression[i + 1].hasClass("mspace") && !expression[i + 1].hasClass("katex-newline")) {
         i++;
         parts.push(expression[i]);
         if (expression[i].hasClass("nobreak")) {
@@ -6042,7 +6029,7 @@ function buildHTML(tree, options) {
         children.push(buildHTMLUnbreakable(parts, options));
         parts = [];
       }
-    } else if (expression[i].hasClass("newline")) {
+    } else if (expression[i].hasClass("katex-newline")) {
       // Write the line except the newline
       parts.pop();
       if (parts.length > 0) {
@@ -6061,7 +6048,7 @@ function buildHTML(tree, options) {
   let tagChild;
   if (tag) {
     tagChild = buildHTMLUnbreakable(buildExpression(tag, options, true), options);
-    tagChild.classes = ["tag"];
+    tagChild.classes = ["katex-tag"];
     children.push(tagChild);
   } else if (eqnNum) {
     children.push(eqnNum);
@@ -6142,10 +6129,10 @@ class MathNode {
    */
   toNode() {
     const node = document.createElementNS("http://www.w3.org/1998/Math/MathML", this.type);
-    for (const attr in this.attributes) {
-      if (Object.prototype.hasOwnProperty.call(this.attributes, attr)) {
-        node.setAttribute(attr, this.attributes[attr]);
-      }
+    for (const _ref of Object.entries(this.attributes)) {
+      const attr = _ref[0];
+      const value = _ref[1];
+      node.setAttribute(attr, value);
     }
     if (this.classes.length > 0) {
       node.className = createClass(this.classes);
@@ -6173,12 +6160,12 @@ class MathNode {
     let markup = "<" + this.type;
 
     // Add the attributes
-    for (const attr in this.attributes) {
-      if (Object.prototype.hasOwnProperty.call(this.attributes, attr)) {
-        markup += " " + attr + "=\"";
-        markup += utils_escape(this.attributes[attr]);
-        markup += "\"";
-      }
+    for (const _ref2 of Object.entries(this.attributes)) {
+      const attr = _ref2[0];
+      const value = _ref2[1];
+      markup += " " + attr + "=\"";
+      markup += utils_escape(value);
+      markup += "\"";
     }
     if (this.classes.length > 0) {
       markup += " class =\"" + utils_escape(createClass(this.classes)) + "\"";
@@ -6325,7 +6312,8 @@ const rowLikeTypes = new Set(["mrow", "mtable"]);
  * optional replacement from symbols.js.
  */
 const makeText = function (text, mode, options) {
-  if (src_symbols[mode][text] && src_symbols[mode][text].replace && text.charCodeAt(0) !== 0xD835 && !(ligatures.hasOwnProperty(text) && options && (options.fontFamily && options.fontFamily.slice(4, 6) === "tt" || options.font && options.font.slice(4, 6) === "tt"))) {
+  var _options$fontFamily, _options$font;
+  if (src_symbols[mode][text] && src_symbols[mode][text].replace && text.charCodeAt(0) !== 0xD835 && !(Object.prototype.hasOwnProperty.call(ligatures, text) && ((options == null || (_options$fontFamily = options.fontFamily) == null ? void 0 : _options$fontFamily.slice(4, 6)) === "tt" || (options == null || (_options$font = options.font) == null ? void 0 : _options$font.slice(4, 6)) === "tt"))) {
     text = src_symbols[mode][text].replace;
   }
   return new TextNode(text);
@@ -6814,7 +6802,7 @@ class Options {
    */
   sizingClasses(oldOptions) {
     if (oldOptions.size !== this.size) {
-      return ["sizing", "reset-size" + oldOptions.size, "size" + this.size];
+      return ["katex-sizing", "reset-size" + oldOptions.size, "size" + this.size];
     } else {
       return [];
     }
@@ -6826,7 +6814,7 @@ class Options {
    */
   baseSizingClasses() {
     if (this.size !== Options.BASESIZE) {
-      return ["sizing", "reset-size" + this.size, "size" + Options.BASESIZE];
+      return ["katex-sizing", "reset-size" + this.size, "size" + Options.BASESIZE];
     } else {
       return [];
     }
@@ -7112,7 +7100,9 @@ const stretchySvg = function (group, options) {
       if (!data) {
         throw new Error("No SVG data for \"" + label + "\".");
       }
-      const [paths, minWidth, viewBoxHeight] = data;
+      const paths = data[0],
+        minWidth = data[1],
+        viewBoxHeight = data[2];
       const height = viewBoxHeight / 1000;
       const numSvgChildren = paths.length;
       let widthClasses;
@@ -7153,17 +7143,16 @@ const stretchySvg = function (group, options) {
         }
       }
       return {
-        span: makeSpan(["stretchy"], spans, options),
+        span: makeSpan(["katex-stretchy"], spans, options),
         minWidth,
         height
       };
     }
   } // buildSvgSpan_()
-  const {
-    span,
-    minWidth,
-    height
-  } = buildSvgSpan_();
+  const _buildSvgSpan_ = buildSvgSpan_(),
+    span = _buildSvgSpan_.span,
+    minWidth = _buildSvgSpan_.minWidth,
+    height = _buildSvgSpan_.height;
 
   // Note that we are returning span.depth = 0.
   // Any adjustments relative to the baseline must be done in buildHTML.
@@ -7179,7 +7168,7 @@ const stretchyEnclose = function (inner, label, topPad, bottomPad, options) {
   let img;
   const totalHeight = inner.height + inner.depth + topPad + bottomPad;
   if (/fbox|color|angl/.test(label)) {
-    img = makeSpan(["stretchy", label], [], options);
+    img = makeSpan(["katex-stretchy", label], [], options);
     if (label === "fbox") {
       const color = options.color && options.getColor();
       if (color) {
@@ -7227,39 +7216,15 @@ const stretchyEnclose = function (inner, label, topPad, bottomPad, options) {
  * pull in `isAtom` without dragging in the ~870-line symbol tables.
  */
 
-// Some of these have a "-token" suffix since these are also used as `ParseNode`
-// types for raw text tokens, and we want to avoid conflicts with higher-level
-// `ParseNode` types. These `ParseNode`s are constructed within `Parser` by
-// looking up the `symbols` map.
-const ATOMS = {
-  "bin": 1,
-  "close": 1,
-  "inner": 1,
-  "open": 1,
-  "punct": 1,
-  "rel": 1
-};
-const NON_ATOMS = {
-  "accent-token": 1,
-  "mathord": 1,
-  "op-token": 1,
-  "spacing": 1,
-  "textord": 1
-};
+const atomList = ["bin", "close", "inner", "open", "punct", "rel"];
+const nonAtomList = ["accent-token", "mathord", "op-token", "spacing", "textord"];
+const Atoms = new Set(atomList);
+const NonAtoms = new Set(nonAtomList);
 function isAtom(value) {
-  return value in ATOMS;
+  return Atoms.has(value);
 }
 ;// ./src/parseNode.ts
 
-
-// ParseNode's corresponding to Symbol `Group`s in symbols.js.
-
-// ParseNode from `Parser.formatUnsupportedCmd`
-
-// Union of all possible `ParseNode<>` types.
-
-// Map from `NodeType` to the corresponding `ParseNode`.
-
 /**
  * Asserts that the node is of the given type and returns it with stricter
  * typing. Throws if the node's type does not match.
@@ -7284,11 +7249,11 @@ function assertSymbolNodeType(node) {
 }
 
 /**
- * Returns the node more strictly typed iff it is of the given type. Otherwise,
+ * Returns the node more strictly typed if it is of the given type. Otherwise,
  * returns null.
  */
 function checkSymbolNodeType(node) {
-  if (node && (node.type === "atom" || NON_ATOMS.hasOwnProperty(node.type))) {
+  if (node.type === "atom" || NonAtoms.has(node.type)) {
     return node;
   }
   return null;
@@ -7388,7 +7353,7 @@ const htmlBuilder = (grp, options) => {
         type: "textord",
         mode: group.mode,
         text: group.label
-      }, options, "textord");
+      }, options);
       accent = assertSymbolDomNode(accent);
       // Remove the italic correction of the accent, because it only serves to
       // shift the accent over to a place we don't want.
@@ -7412,7 +7377,7 @@ const htmlBuilder = (grp, options) => {
     // Shift the accent over by the skew.
     let left = skew;
 
-    // CSS defines `.katex .accent .accent-body:not(.accent-full) { width: 0 }`
+    // CSS defines `.katex .katex-accent .accent-body:not(.accent-full) { width: 0 }`
     // so that the accent doesn't contribute to the bounding box.
     // We need to shift the character by its width (effectively half
     // its width) to compensate.
@@ -7457,7 +7422,7 @@ const htmlBuilder = (grp, options) => {
       }]
     }, options);
   }
-  const accentWrap = makeSpan(["mord", "accent"], [accentBody], options);
+  const accentWrap = makeSpan(["mord", "katex-accent"], [accentBody], options);
   if (supSubGroup) {
     // Here, we replace the "base" child of the supsub with our newly
     // generated accent.
@@ -7486,9 +7451,7 @@ const NON_STRETCHY_ACCENT_REGEX = new RegExp(["\\acute", "\\grave", "\\ddot", "\
 defineFunction({
   type: "accent",
   names: ["\\acute", "\\grave", "\\ddot", "\\tilde", "\\bar", "\\breve", "\\check", "\\hat", "\\vec", "\\dot", "\\mathring", "\\widecheck", "\\widehat", "\\widetilde", "\\overrightarrow", "\\overleftarrow", "\\Overrightarrow", "\\overleftrightarrow", "\\overgroup", "\\overlinesegment", "\\overleftharpoon", "\\overrightharpoon"],
-  props: {
-    numArgs: 1
-  },
+  numArgs: 1,
   handler: (context, args) => {
     const base = normalizeArgument(args[0]);
     const isStretchy = !NON_STRETCHY_ACCENT_REGEX.test(context.funcName);
@@ -7510,13 +7473,11 @@ defineFunction({
 defineFunction({
   type: "accent",
   names: ["\\'", "\\`", "\\^", "\\~", "\\=", "\\u", "\\.", '\\"', "\\c", "\\r", "\\H", "\\v", "\\textcircled"],
-  props: {
-    numArgs: 1,
-    allowedInText: true,
-    allowedInMath: true,
-    // unless in strict mode
-    argTypes: ["primitive"]
-  },
+  numArgs: 1,
+  allowedInText: true,
+  allowedInMath: true,
+  // unless in strict mode
+  argTypes: ["primitive"],
   handler: (context, args) => {
     const base = args[0];
     let mode = context.parser.mode;
@@ -7532,9 +7493,7 @@ defineFunction({
       isShifty: true,
       base: base
     };
-  },
-  htmlBuilder,
-  mathmlBuilder
+  }
 });
 ;// ./src/functions/accentunder.ts
 // Horizontal overlap functions
@@ -7547,14 +7506,10 @@ defineFunction({
 defineFunction({
   type: "accentUnder",
   names: ["\\underleftarrow", "\\underrightarrow", "\\underleftrightarrow", "\\undergroup", "\\underlinesegment", "\\utilde"],
-  props: {
-    numArgs: 1
-  },
+  numArgs: 1,
   handler: (_ref, args) => {
-    let {
-      parser,
-      funcName
-    } = _ref;
+    let parser = _ref.parser,
+      funcName = _ref.funcName;
     const base = args[0];
     return {
       type: "accentUnder",
@@ -7618,15 +7573,11 @@ defineFunction({
   "\\xrightleftarrows", "\\xrightequilibrium", "\\xleftequilibrium",
   // The next 3 functions are here only to support the {CD} environment.
   "\\\\cdrightarrow", "\\\\cdleftarrow", "\\\\cdlongequal"],
-  props: {
-    numArgs: 1,
-    numOptionalArgs: 1
-  },
+  numArgs: 1,
+  numOptionalArgs: 1,
   handler(_ref, args, optArgs) {
-    let {
-      parser,
-      funcName
-    } = _ref;
+    let parser = _ref.parser,
+      funcName = _ref.funcName;
     return {
       type: "xArrow",
       mode: parser.mode,
@@ -7769,9 +7720,6 @@ function mclass_mathmlBuilder(group, options) {
     } else if (group.mclass === "mopen" || group.mclass === "mclose") {
       node.attributes.lspace = "0em";
       node.attributes.rspace = "0em";
-    } else if (group.mclass === "minner") {
-      node.attributes.lspace = "0.0556em"; // 1 mu is the most likely option
-      node.attributes.width = "+0.1111em";
     }
     // MathML <mo> default space is 5/18 em, so <mrel> needs no action.
     // Ref: https://developer.mozilla.org/en-US/docs/Web/MathML/Element/mo
@@ -7783,21 +7731,16 @@ function mclass_mathmlBuilder(group, options) {
 defineFunction({
   type: "mclass",
   names: ["\\mathord", "\\mathbin", "\\mathrel", "\\mathopen", "\\mathclose", "\\mathpunct", "\\mathinner"],
-  props: {
-    numArgs: 1,
-    primitive: true
-  },
+  numArgs: 1,
+  primitive: true,
   handler(_ref, args) {
-    let {
-      parser,
-      funcName
-    } = _ref;
+    let parser = _ref.parser,
+      funcName = _ref.funcName;
     const body = args[0];
     return {
       type: "mclass",
       mode: parser.mode,
       mclass: "m" + funcName.slice(5),
-      // TODO(kevinb): don't prefix with 'm'
       body: ordargument(body),
       isCharacterBox: isCharacterBox(body)
     };
@@ -7823,13 +7766,9 @@ const binrelClass = arg => {
 defineFunction({
   type: "mclass",
   names: ["\\@binrel"],
-  props: {
-    numArgs: 2
-  },
+  numArgs: 2,
   handler(_ref2, args) {
-    let {
-      parser
-    } = _ref2;
+    let parser = _ref2.parser;
     return {
       type: "mclass",
       mode: parser.mode,
@@ -7844,14 +7783,10 @@ defineFunction({
 defineFunction({
   type: "mclass",
   names: ["\\stackrel", "\\overset", "\\underset"],
-  props: {
-    numArgs: 2
-  },
+  numArgs: 2,
   handler(_ref3, args) {
-    let {
-      parser,
-      funcName
-    } = _ref3;
+    let parser = _ref3.parser,
+      funcName = _ref3.funcName;
     const baseArg = args[1];
     const shiftedArg = args[0];
     let mclass;
@@ -7871,12 +7806,16 @@ defineFunction({
       suppressBaseShift: funcName !== "\\stackrel",
       body: ordargument(baseArg)
     };
-    const supsub = {
+    const supsub = funcName === "\\underset" ? {
       type: "supsub",
       mode: shiftedArg.mode,
       base: baseOp,
-      sup: funcName === "\\underset" ? null : shiftedArg,
-      sub: funcName === "\\underset" ? shiftedArg : null
+      sub: shiftedArg
+    } : {
+      type: "supsub",
+      mode: shiftedArg.mode,
+      base: baseOp,
+      sup: shiftedArg
     };
     return {
       type: "mclass",
@@ -7885,9 +7824,7 @@ defineFunction({
       body: [supsub],
       isCharacterBox: isCharacterBox(supsub)
     };
-  },
-  htmlBuilder: mclass_htmlBuilder,
-  mathmlBuilder: mclass_mathmlBuilder
+  }
 });
 ;// ./src/functions/pmb.ts
 
@@ -7904,14 +7841,10 @@ defineFunction({
 defineFunction({
   type: "pmb",
   names: ["\\pmb"],
-  props: {
-    numArgs: 1,
-    allowedInText: true
-  },
+  numArgs: 1,
+  allowedInText: true,
   handler(_ref, args) {
-    let {
-      parser
-    } = _ref;
+    let parser = _ref.parser;
     return {
       type: "pmb",
       mode: parser.mode,
@@ -8175,14 +8108,10 @@ function parseCD(parser) {
 defineFunction({
   type: "cdlabel",
   names: ["\\\\cdleft", "\\\\cdright"],
-  props: {
-    numArgs: 1
-  },
+  numArgs: 1,
   handler(_ref, args) {
-    let {
-      parser,
-      funcName
-    } = _ref;
+    let parser = _ref.parser,
+      funcName = _ref.funcName;
     return {
       type: "cdlabel",
       mode: parser.mode,
@@ -8220,13 +8149,9 @@ defineFunction({
 defineFunction({
   type: "cdlabelparent",
   names: ["\\\\cdparent"],
-  props: {
-    numArgs: 1
-  },
+  numArgs: 1,
   handler(_ref2, args) {
-    let {
-      parser
-    } = _ref2;
+    let parser = _ref2.parser;
     return {
       type: "cdlabelparent",
       mode: parser.mode,
@@ -8256,14 +8181,10 @@ defineFunction({
 defineFunction({
   type: "textord",
   names: ["\\@char"],
-  props: {
-    numArgs: 1,
-    allowedInText: true
-  },
+  numArgs: 1,
+  allowedInText: true,
   handler(_ref, args) {
-    let {
-      parser
-    } = _ref;
+    let parser = _ref.parser;
     const arg = assertNodeType(args[0], "ordgroup");
     const group = arg.body;
     let number = "";
@@ -8318,15 +8239,11 @@ const color_mathmlBuilder = (group, options) => {
 defineFunction({
   type: "color",
   names: ["\\textcolor"],
-  props: {
-    numArgs: 2,
-    allowedInText: true,
-    argTypes: ["color", "original"]
-  },
+  numArgs: 2,
+  allowedInText: true,
+  argTypes: ["color", "original"],
   handler(_ref, args) {
-    let {
-      parser
-    } = _ref;
+    let parser = _ref.parser;
     const color = assertNodeType(args[0], "color-token").color;
     const body = args[1];
     return {
@@ -8342,16 +8259,12 @@ defineFunction({
 defineFunction({
   type: "color",
   names: ["\\color"],
-  props: {
-    numArgs: 1,
-    allowedInText: true,
-    argTypes: ["color"]
-  },
+  numArgs: 1,
+  allowedInText: true,
+  argTypes: ["color"],
   handler(_ref2, args) {
-    let {
-      parser,
-      breakOnTokenText
-    } = _ref2;
+    let parser = _ref2.parser,
+      breakOnTokenText = _ref2.breakOnTokenText;
     const color = assertNodeType(args[0], "color-token").color;
 
     // Set macro \current@color in current namespace to store the current
@@ -8368,9 +8281,7 @@ defineFunction({
       color,
       body
     };
-  },
-  htmlBuilder: color_htmlBuilder,
-  mathmlBuilder: color_mathmlBuilder
+  }
 });
 ;// ./src/functions/cr.ts
 // Row breaks within tabular environments, and line breaks at top level
@@ -8385,15 +8296,11 @@ defineFunction({
 defineFunction({
   type: "cr",
   names: ["\\\\"],
-  props: {
-    numArgs: 0,
-    numOptionalArgs: 0,
-    allowedInText: true
-  },
+  numArgs: 0,
+  numOptionalArgs: 0,
+  allowedInText: true,
   handler(_ref, args, optArgs) {
-    let {
-      parser
-    } = _ref;
+    let parser = _ref.parser;
     const size = parser.gullet.future().text === "[" ? parser.parseSizeGroup(true) : null;
     const newLine = !parser.settings.displayMode || !parser.settings.useStrictBehavior("newLineInDisplayMode", "In LaTeX, \\\\ or \\newline " + "does nothing in display mode");
     return {
@@ -8409,7 +8316,7 @@ defineFunction({
   htmlBuilder(group, options) {
     const span = makeSpan(["mspace"], [], options);
     if (group.newLine) {
-      span.classes.push("newline");
+      span.classes.push("katex-newline");
       if (group.size) {
         span.style.marginTop = makeEm(calculateSize(group.size, options));
       }
@@ -8485,15 +8392,11 @@ defineFunction({
   type: "internal",
   names: ["\\global", "\\long", "\\\\globallong" // can’t be entered directly
   ],
-  props: {
-    numArgs: 0,
-    allowedInText: true
-  },
+  numArgs: 0,
+  allowedInText: true,
   handler(_ref) {
-    let {
-      parser,
-      funcName
-    } = _ref;
+    let parser = _ref.parser,
+      funcName = _ref.funcName;
     parser.consumeSpaces();
     const token = parser.fetch();
     if (globalMap[token.text]) {
@@ -8514,16 +8417,12 @@ defineFunction({
 defineFunction({
   type: "internal",
   names: ["\\def", "\\gdef", "\\edef", "\\xdef"],
-  props: {
-    numArgs: 0,
-    allowedInText: true,
-    primitive: true
-  },
+  numArgs: 0,
+  allowedInText: true,
+  primitive: true,
   handler(_ref2) {
-    let {
-      parser,
-      funcName
-    } = _ref2;
+    let parser = _ref2.parser,
+      funcName = _ref2.funcName;
     let tok = parser.gullet.popToken();
     const name = tok.text;
     if (/^(?:[\\{}$&#^_]|EOF)$/.test(name)) {
@@ -8564,9 +8463,8 @@ defineFunction({
       }
     }
     // replacement text, enclosed in '{' and '}' and properly nested
-    let {
-      tokens
-    } = parser.gullet.consumeArg();
+    let _parser$gullet$consum = parser.gullet.consumeArg(),
+      tokens = _parser$gullet$consum.tokens;
     if (insert) {
       tokens.unshift(insert);
     }
@@ -8595,16 +8493,12 @@ defineFunction({
   type: "internal",
   names: ["\\let", "\\\\globallet" // can’t be entered directly
   ],
-  props: {
-    numArgs: 0,
-    allowedInText: true,
-    primitive: true
-  },
+  numArgs: 0,
+  allowedInText: true,
+  primitive: true,
   handler(_ref3) {
-    let {
-      parser,
-      funcName
-    } = _ref3;
+    let parser = _ref3.parser,
+      funcName = _ref3.funcName;
     const name = checkControlSequence(parser.gullet.popToken());
     parser.gullet.consumeSpaces();
     const tok = getRHS(parser);
@@ -8621,16 +8515,12 @@ defineFunction({
   type: "internal",
   names: ["\\futurelet", "\\\\globalfuture" // can’t be entered directly
   ],
-  props: {
-    numArgs: 0,
-    allowedInText: true,
-    primitive: true
-  },
+  numArgs: 0,
+  allowedInText: true,
+  primitive: true,
   handler(_ref4) {
-    let {
-      parser,
-      funcName
-    } = _ref4;
+    let parser = _ref4.parser,
+      funcName = _ref4.funcName;
     const name = checkControlSequence(parser.gullet.popToken());
     const middle = parser.gullet.popToken();
     const tok = parser.gullet.popToken();
@@ -9450,10 +9340,8 @@ function checkDelimiter(delim, context) {
 defineFunction({
   type: "delimsizing",
   names: ["\\bigl", "\\Bigl", "\\biggl", "\\Biggl", "\\bigr", "\\Bigr", "\\biggr", "\\Biggr", "\\bigm", "\\Bigm", "\\biggm", "\\Biggm", "\\big", "\\Big", "\\bigg", "\\Bigg"],
-  props: {
-    numArgs: 1,
-    argTypes: ["primitive"]
-  },
+  numArgs: 1,
+  argTypes: ["primitive"],
   handler: (context, args) => {
     const delim = checkDelimiter(args[0], context);
     return {
@@ -9502,10 +9390,8 @@ function assertParsed(group) {
 defineFunction({
   type: "leftright-right",
   names: ["\\right"],
-  props: {
-    numArgs: 1,
-    primitive: true
-  },
+  numArgs: 1,
+  primitive: true,
   handler: (context, args) => {
     // \left case below triggers parsing of \right in
     //   `const right = parser.parseFunction();`
@@ -9518,17 +9404,15 @@ defineFunction({
       type: "leftright-right",
       mode: context.parser.mode,
       delim: checkDelimiter(args[0], context).text,
-      color: color // undefined if not set via \color
+      color // undefined if not set via \color
     };
   }
 });
 defineFunction({
   type: "leftright",
   names: ["\\left"],
-  props: {
-    numArgs: 1,
-    primitive: true
-  },
+  numArgs: 1,
+  primitive: true,
   handler: (context, args) => {
     const delim = checkDelimiter(args[0], context);
     const parser = context.parser;
@@ -9630,10 +9514,8 @@ defineFunction({
 defineFunction({
   type: "middle",
   names: ["\\middle"],
-  props: {
-    numArgs: 1,
-    primitive: true
-  },
+  numArgs: 1,
+  primitive: true,
   handler: (context, args) => {
     const delim = checkDelimiter(args[0], context);
     if (!context.parser.leftrightDepth) {
@@ -9707,7 +9589,7 @@ const enclose_htmlBuilder = (group, options) => {
   // subjects that should get the "tall" treatment.
   const isSingleChar = isCharacterBox(group.body);
   if (label === "sout") {
-    img = makeSpan(["stretchy", "sout"]);
+    img = makeSpan(["katex-stretchy", "katex-sout"]);
     img.height = options.fontMetrics().defaultRuleThickness / scale;
     imgShift = -0.5 * options.fontMetrics().xHeight;
   } else if (label === "phase") {
@@ -9887,16 +9769,12 @@ const enclose_mathmlBuilder = (group, options) => {
 defineFunction({
   type: "enclose",
   names: ["\\colorbox"],
-  props: {
-    numArgs: 2,
-    allowedInText: true,
-    argTypes: ["color", "hbox"]
-  },
+  numArgs: 2,
+  allowedInText: true,
+  argTypes: ["color", "hbox"],
   handler(_ref, args, optArgs) {
-    let {
-      parser,
-      funcName
-    } = _ref;
+    let parser = _ref.parser,
+      funcName = _ref.funcName;
     const color = assertNodeType(args[0], "color-token").color;
     const body = args[1];
     return {
@@ -9913,16 +9791,12 @@ defineFunction({
 defineFunction({
   type: "enclose",
   names: ["\\fcolorbox"],
-  props: {
-    numArgs: 3,
-    allowedInText: true,
-    argTypes: ["color", "color", "hbox"]
-  },
+  numArgs: 3,
+  allowedInText: true,
+  argTypes: ["color", "color", "hbox"],
   handler(_ref2, args, optArgs) {
-    let {
-      parser,
-      funcName
-    } = _ref2;
+    let parser = _ref2.parser,
+      funcName = _ref2.funcName;
     const borderColor = assertNodeType(args[0], "color-token").color;
     const backgroundColor = assertNodeType(args[1], "color-token").color;
     const body = args[2];
@@ -9934,22 +9808,16 @@ defineFunction({
       borderColor,
       body
     };
-  },
-  htmlBuilder: enclose_htmlBuilder,
-  mathmlBuilder: enclose_mathmlBuilder
+  }
 });
 defineFunction({
   type: "enclose",
   names: ["\\fbox"],
-  props: {
-    numArgs: 1,
-    argTypes: ["hbox"],
-    allowedInText: true
-  },
+  numArgs: 1,
+  argTypes: ["hbox"],
+  allowedInText: true,
   handler(_ref3, args) {
-    let {
-      parser
-    } = _ref3;
+    let parser = _ref3.parser;
     return {
       type: "enclose",
       mode: parser.mode,
@@ -9961,14 +9829,10 @@ defineFunction({
 defineFunction({
   type: "enclose",
   names: ["\\cancel", "\\bcancel", "\\xcancel", "\\phase"],
-  props: {
-    numArgs: 1
-  },
+  numArgs: 1,
   handler(_ref4, args) {
-    let {
-      parser,
-      funcName
-    } = _ref4;
+    let parser = _ref4.parser,
+      funcName = _ref4.funcName;
     const body = args[0];
     return {
       type: "enclose",
@@ -9976,22 +9840,16 @@ defineFunction({
       label: funcName,
       body
     };
-  },
-  htmlBuilder: enclose_htmlBuilder,
-  mathmlBuilder: enclose_mathmlBuilder
+  }
 });
 defineFunction({
   type: "enclose",
   names: ["\\sout"],
-  props: {
-    numArgs: 1,
-    allowedInText: true
-  },
+  numArgs: 1,
+  allowedInText: true,
   handler(_ref5, args) {
-    let {
-      parser,
-      funcName
-    } = _ref5;
+    let parser = _ref5.parser,
+      funcName = _ref5.funcName;
     if (parser.mode === "math") {
       parser.settings.reportNonstrict("mathVsSout", "LaTeX's \\sout works only in text mode");
     }
@@ -10002,22 +9860,16 @@ defineFunction({
       label: funcName,
       body
     };
-  },
-  htmlBuilder: enclose_htmlBuilder,
-  mathmlBuilder: enclose_mathmlBuilder
+  }
 });
 defineFunction({
   type: "enclose",
   names: ["\\angl"],
-  props: {
-    numArgs: 1,
-    argTypes: ["hbox"],
-    allowedInText: false
-  },
+  numArgs: 1,
+  argTypes: ["hbox"],
+  allowedInText: false,
   handler(_ref6, args) {
-    let {
-      parser
-    } = _ref6;
+    let parser = _ref6.parser;
     return {
       type: "enclose",
       mode: parser.mode,
@@ -10065,14 +9917,12 @@ defineFunction({
  */
 const _environments = {};
 function defineEnvironment(_ref) {
-  let {
-    type,
-    names,
-    props,
-    handler,
-    htmlBuilder,
-    mathmlBuilder
-  } = _ref;
+  let type = _ref.type,
+    names = _ref.names,
+    props = _ref.props,
+    handler = _ref.handler,
+    htmlBuilder = _ref.htmlBuilder,
+    mathmlBuilder = _ref.mathmlBuilder;
   // Set default values of environments.
   const data = {
     type,
@@ -10266,18 +10116,16 @@ function getAutoTag(name) {
  * ("text", "display", etc.), then each cell is cast into that style.
  */
 function parseArray(parser, _ref, style) {
-  let {
-    hskipBeforeAndAfter,
-    addJot,
-    cols,
-    arraystretch,
-    colSeparationType,
-    autoTag,
-    singleRow,
-    emptySingleRow,
-    maxNumCols,
-    leqno
-  } = _ref;
+  let hskipBeforeAndAfter = _ref.hskipBeforeAndAfter,
+    addJot = _ref.addJot,
+    cols = _ref.cols,
+    arraystretch = _ref.arraystretch,
+    colSeparationType = _ref.colSeparationType,
+    autoTag = _ref.autoTag,
+    singleRow = _ref.singleRow,
+    emptySingleRow = _ref.emptySingleRow,
+    maxNumCols = _ref.maxNumCols,
+    leqno = _ref.leqno;
   parser.gullet.beginGroup();
   if (!singleRow) {
     // \cr is equivalent to \\ without the optional size argument (see below)
@@ -10651,8 +10499,8 @@ const array_htmlBuilder = function (group, options) {
 
   // Add \hline(s), if any.
   if (hlines.length > 0) {
-    const line = makeLineSpan("hline", options, ruleThickness);
-    const dashes = makeLineSpan("hdashline", options, ruleThickness);
+    const line = makeLineSpan("katex-hline", options, ruleThickness);
+    const dashes = makeLineSpan("katex-hdashline", options, ruleThickness);
     const vListElems = [{
       type: "elem",
       elem: tableBody,
@@ -10687,7 +10535,7 @@ const array_htmlBuilder = function (group, options) {
       positionType: "individualShift",
       children: tagSpans
     }, options);
-    const tagCol = makeSpan(["tag"], [eqnNumCol], options);
+    const tagCol = makeSpan(["katex-tag"], [eqnNumCol], options);
     return makeFragment([tableBody, tagCol]);
   }
 };
@@ -10827,14 +10675,13 @@ const alignedHandler = function (context, args) {
     validateAmsEnvironmentContext(context);
   }
   const cols = [];
-  const separationType = context.envName.includes("at") ? "alignat" : "align";
   const isSplit = context.envName === "split";
   const res = parseArray(context.parser, {
     cols,
     addJot: true,
     autoTag: isSplit ? undefined : getAutoTag(context.envName),
     emptySingleRow: true,
-    colSeparationType: separationType,
+    colSeparationType: context.envName.includes("at") ? "alignat" : "align",
     maxNumCols: isSplit ? 2 : undefined,
     leqno: context.parser.settings.leqno
   }, "display");
@@ -11229,11 +11076,9 @@ defineFunction({
   type: "text",
   // Doesn't matter what this is.
   names: ["\\hline", "\\hdashline"],
-  props: {
-    numArgs: 0,
-    allowedInText: true,
-    allowedInMath: true
-  },
+  numArgs: 0,
+  allowedInText: true,
+  allowedInMath: true,
   handler(context, args) {
     throw new src_ParseError(context.funcName + " valid only within array environment");
   }
@@ -11255,15 +11100,11 @@ const environments = _environments;
 defineFunction({
   type: "environment",
   names: ["\\begin", "\\end"],
-  props: {
-    numArgs: 1,
-    argTypes: ["text"]
-  },
+  numArgs: 1,
+  argTypes: ["text"],
   handler(_ref, args) {
-    let {
-      parser,
-      funcName
-    } = _ref;
+    let parser = _ref.parser,
+      funcName = _ref.funcName;
     const nameGroup = args[0];
     if (nameGroup.type !== "ordgroup") {
       throw new src_ParseError("Invalid environment name", nameGroup);
@@ -11274,16 +11115,15 @@ defineFunction({
     }
     if (funcName === "\\begin") {
       // begin...end is similar to left...right
-      if (!src_environments.hasOwnProperty(envName)) {
+      if (!Object.prototype.hasOwnProperty.call(src_environments, envName)) {
         throw new src_ParseError("No such environment: " + envName, nameGroup);
       }
       // Build the environment object. Arguments and other information will
       // be made available to the begin and end methods using properties.
       const env = src_environments[envName];
-      const {
-        args,
-        optArgs
-      } = parser.parseArguments("\\begin{" + envName + "}", env);
+      const _parser$parseArgument = parser.parseArguments("\\begin{" + envName + "}", env),
+        args = _parser$parseArgument.args,
+        optArgs = _parser$parseArgument.optArgs;
       const context = {
         mode: parser.mode,
         envName,
@@ -11342,20 +11182,13 @@ defineFunction({
   "\\mathbb", "\\mathcal", "\\mathfrak", "\\mathscr", "\\mathsf", "\\mathtt",
   // aliases, except \bm defined below
   "\\Bbb", "\\bold", "\\frak"],
-  props: {
-    numArgs: 1,
-    allowedInArgument: true
-  },
+  numArgs: 1,
+  allowedInArgument: true,
   handler: (_ref, args) => {
-    let {
-      parser,
-      funcName
-    } = _ref;
+    let parser = _ref.parser,
+      funcName = _ref.funcName;
     const body = normalizeArgument(args[0]);
-    let func = funcName;
-    if (func in fontAliases) {
-      func = fontAliases[func];
-    }
+    const func = funcName in fontAliases ? fontAliases[funcName] : funcName;
     return {
       type: "font",
       mode: parser.mode,
@@ -11369,13 +11202,9 @@ defineFunction({
 defineFunction({
   type: "mclass",
   names: ["\\boldsymbol", "\\bm"],
-  props: {
-    numArgs: 1
-  },
+  numArgs: 1,
   handler: (_ref2, args) => {
-    let {
-      parser
-    } = _ref2;
+    let parser = _ref2.parser;
     const body = args[0];
     // amsbsy.sty's \boldsymbol uses \binrel spacing to inherit the
     // argument's bin|rel|ord status
@@ -11398,19 +11227,13 @@ defineFunction({
 defineFunction({
   type: "font",
   names: ["\\rm", "\\sf", "\\tt", "\\bf", "\\it", "\\cal"],
-  props: {
-    numArgs: 0,
-    allowedInText: true
-  },
+  numArgs: 0,
+  allowedInText: true,
   handler: (_ref3, args) => {
-    let {
-      parser,
-      funcName,
-      breakOnTokenText
-    } = _ref3;
-    const {
-      mode
-    } = parser;
+    let parser = _ref3.parser,
+      funcName = _ref3.funcName,
+      breakOnTokenText = _ref3.breakOnTokenText;
+    const mode = parser.mode;
     const body = parser.parseExpression(true, breakOnTokenText);
     return {
       type: "font",
@@ -11422,9 +11245,7 @@ defineFunction({
         body
       }
     };
-  },
-  htmlBuilder: font_htmlBuilder,
-  mathmlBuilder: font_mathmlBuilder
+  }
 });
 ;// ./src/functions/genfrac.ts
 
@@ -11618,15 +11439,11 @@ defineFunction({
   // can’t be entered directly
   "\\\\bracefrac", "\\\\brackfrac" // ditto
   ],
-  props: {
-    numArgs: 2,
-    allowedInArgument: true
-  },
+  numArgs: 2,
+  allowedInArgument: true,
   handler: (_ref, args) => {
-    let {
-      parser,
-      funcName
-    } = _ref;
+    let parser = _ref.parser,
+      funcName = _ref.funcName;
     const numer = args[0];
     const denom = args[1];
     let hasBarLine;
@@ -11690,16 +11507,12 @@ defineFunction({
 defineFunction({
   type: "infix",
   names: ["\\over", "\\choose", "\\atop", "\\brace", "\\brack"],
-  props: {
-    numArgs: 0,
-    infix: true
-  },
+  numArgs: 0,
+  infix: true,
   handler(_ref2) {
-    let {
-      parser,
-      funcName,
-      token
-    } = _ref2;
+    let parser = _ref2.parser,
+      funcName = _ref2.funcName,
+      token = _ref2.token;
     let replaceWith;
     switch (funcName) {
       case "\\over":
@@ -11740,15 +11553,11 @@ const delimFromValue = function (delimString) {
 defineFunction({
   type: "genfrac",
   names: ["\\genfrac"],
-  props: {
-    numArgs: 6,
-    allowedInArgument: true,
-    argTypes: ["math", "math", "size", "text", "math", "math"]
-  },
+  numArgs: 6,
+  allowedInArgument: true,
+  argTypes: ["math", "math", "size", "text", "math", "math"],
   handler(_ref3, args) {
-    let {
-      parser
-    } = _ref3;
+    let parser = _ref3.parser;
     const numer = args[4];
     const denom = args[5];
 
@@ -11800,17 +11609,13 @@ defineFunction({
 defineFunction({
   type: "infix",
   names: ["\\above"],
-  props: {
-    numArgs: 1,
-    argTypes: ["size"],
-    infix: true
-  },
+  numArgs: 1,
+  argTypes: ["size"],
+  infix: true,
   handler(_ref4, args) {
-    let {
-      parser,
-      funcName,
-      token
-    } = _ref4;
+    let parser = _ref4.parser,
+      funcName = _ref4.funcName,
+      token = _ref4.token;
     return {
       type: "infix",
       mode: parser.mode,
@@ -11823,15 +11628,11 @@ defineFunction({
 defineFunction({
   type: "genfrac",
   names: ["\\\\abovefrac"],
-  props: {
-    numArgs: 3,
-    argTypes: ["math", "size", "math"]
-  },
+  numArgs: 3,
+  argTypes: ["math", "size", "math"],
   handler: (_ref5, args) => {
-    let {
-      parser,
-      funcName
-    } = _ref5;
+    let parser = _ref5.parser,
+      funcName = _ref5.funcName;
     const numer = args[0];
     const barSize = assertNodeType(args[1], "infix").size;
     if (!barSize) {
@@ -11973,14 +11774,10 @@ const horizBrace_mathmlBuilder = (group, options) => {
 defineFunction({
   type: "horizBrace",
   names: ["\\overbrace", "\\underbrace", "\\overbracket", "\\underbracket"],
-  props: {
-    numArgs: 1
-  },
+  numArgs: 1,
   handler(_ref, args) {
-    let {
-      parser,
-      funcName
-    } = _ref;
+    let parser = _ref.parser,
+      funcName = _ref.funcName;
     return {
       type: "horizBrace",
       mode: parser.mode,
@@ -12002,15 +11799,11 @@ defineFunction({
 defineFunction({
   type: "href",
   names: ["\\href"],
-  props: {
-    numArgs: 2,
-    argTypes: ["url", "original"],
-    allowedInText: true
-  },
+  numArgs: 2,
+  argTypes: ["url", "original"],
+  allowedInText: true,
   handler: (_ref, args) => {
-    let {
-      parser
-    } = _ref;
+    let parser = _ref.parser;
     const body = args[1];
     const href = assertNodeType(args[0], "url").url;
     if (!parser.settings.isTrusted({
@@ -12042,15 +11835,11 @@ defineFunction({
 defineFunction({
   type: "href",
   names: ["\\url"],
-  props: {
-    numArgs: 1,
-    argTypes: ["url"],
-    allowedInText: true
-  },
+  numArgs: 1,
+  argTypes: ["url"],
+  allowedInText: true,
   handler: (_ref2, args) => {
-    let {
-      parser
-    } = _ref2;
+    let parser = _ref2.parser;
     const href = assertNodeType(args[0], "url").url;
     if (!parser.settings.isTrusted({
       command: "\\url",
@@ -12099,16 +11888,12 @@ defineFunction({
 defineFunction({
   type: "hbox",
   names: ["\\hbox"],
-  props: {
-    numArgs: 1,
-    argTypes: ["text"],
-    allowedInText: true,
-    primitive: true
-  },
+  numArgs: 1,
+  argTypes: ["text"],
+  allowedInText: true,
+  primitive: true,
   handler(_ref, args) {
-    let {
-      parser
-    } = _ref;
+    let parser = _ref.parser;
     return {
       type: "hbox",
       mode: parser.mode,
@@ -12133,17 +11918,13 @@ defineFunction({
 defineFunction({
   type: "html",
   names: ["\\htmlClass", "\\htmlId", "\\htmlStyle", "\\htmlData"],
-  props: {
-    numArgs: 2,
-    argTypes: ["raw", "original"],
-    allowedInText: true
-  },
+  numArgs: 2,
+  argTypes: ["raw", "original"],
+  allowedInText: true,
   handler: (_ref, args) => {
-    let {
-      parser,
-      funcName,
-      token
-    } = _ref;
+    let parser = _ref.parser,
+      funcName = _ref.funcName,
+      token = _ref.token;
     const value = assertNodeType(args[0], "raw").string;
     const body = args[1];
     if (parser.settings.strict) {
@@ -12212,9 +11993,11 @@ defineFunction({
       classes.push(...group.attributes.class.trim().split(/\s+/));
     }
     const span = makeSpan(classes, elements, options);
-    for (const attr in group.attributes) {
-      if (attr !== "class" && group.attributes.hasOwnProperty(attr)) {
-        span.setAttribute(attr, group.attributes[attr]);
+    for (const _ref2 of Object.entries(group.attributes)) {
+      const attr = _ref2[0];
+      const value = _ref2[1];
+      if (attr !== "class") {
+        span.setAttribute(attr, value);
       }
     }
     return span;
@@ -12231,15 +12014,11 @@ defineFunction({
 defineFunction({
   type: "htmlmathml",
   names: ["\\html@mathml"],
-  props: {
-    numArgs: 2,
-    allowedInArgument: true,
-    allowedInText: true
-  },
+  numArgs: 2,
+  allowedInArgument: true,
+  allowedInText: true,
   handler: (_ref, args) => {
-    let {
-      parser
-    } = _ref;
+    let parser = _ref.parser;
     return {
       type: "htmlmathml",
       mode: parser.mode,
@@ -12289,16 +12068,12 @@ const sizeData = function (str) {
 defineFunction({
   type: "includegraphics",
   names: ["\\includegraphics"],
-  props: {
-    numArgs: 1,
-    numOptionalArgs: 1,
-    argTypes: ["raw", "url"],
-    allowedInText: false
-  },
+  numArgs: 1,
+  numOptionalArgs: 1,
+  argTypes: ["raw", "url"],
+  allowedInText: false,
   handler: (_ref, args, optArgs) => {
-    let {
-      parser
-    } = _ref;
+    let parser = _ref.parser;
     let width = {
       number: 0,
       unit: "em"
@@ -12419,17 +12194,13 @@ defineFunction({
 defineFunction({
   type: "kern",
   names: ["\\kern", "\\mkern", "\\hskip", "\\mskip"],
-  props: {
-    numArgs: 1,
-    argTypes: ["size"],
-    primitive: true,
-    allowedInText: true
-  },
+  numArgs: 1,
+  argTypes: ["size"],
+  primitive: true,
+  allowedInText: true,
   handler(_ref, args) {
-    let {
-      parser,
-      funcName
-    } = _ref;
+    let parser = _ref.parser,
+      funcName = _ref.funcName;
     const size = assertNodeType(args[0], "size");
     if (parser.settings.strict) {
       const mathFunction = funcName[1] === 'm'; // \mkern, \mskip
@@ -12473,15 +12244,11 @@ defineFunction({
 defineFunction({
   type: "lap",
   names: ["\\mathllap", "\\mathrlap", "\\mathclap"],
-  props: {
-    numArgs: 1,
-    allowedInText: true
-  },
+  numArgs: 1,
+  allowedInText: true,
   handler: (_ref, args) => {
-    let {
-      parser,
-      funcName
-    } = _ref;
+    let parser = _ref.parser,
+      funcName = _ref.funcName;
     const body = args[0];
     return {
       type: "lap",
@@ -12496,12 +12263,12 @@ defineFunction({
     if (group.alignment === "clap") {
       // ref: https://www.math.lsu.edu/~aperlis/publications/mathclap/
       inner = makeSpan([], [buildGroup(group.body, options)]);
-      // wrap, since CSS will center a .clap > .inner > span
-      inner = makeSpan(["inner"], [inner], options);
+      // wrap, since CSS will center a .clap > .katex-inner > span
+      inner = makeSpan(["katex-inner"], [inner], options);
     } else {
-      inner = makeSpan(["inner"], [buildGroup(group.body, options)]);
+      inner = makeSpan(["katex-inner"], [buildGroup(group.body, options)]);
     }
-    const fix = makeSpan(["fix"], []);
+    const fix = makeSpan(["katex-fix"], []);
     let node = makeSpan([group.alignment], [inner, fix], options);
 
     // At this point, we have correctly set horizontal alignment of the
@@ -12509,7 +12276,7 @@ defineFunction({
     // Next, use a strut to set the height of the HTML bounding box.
     // Otherwise, a tall argument may be misplaced.
     // This code resolved issue #1153
-    const strut = makeSpan(["strut"]);
+    const strut = makeSpan(["katex-strut"]);
     strut.style.height = makeEm(node.height + node.depth);
     if (node.depth) {
       strut.style.verticalAlign = makeEm(-node.depth);
@@ -12518,8 +12285,8 @@ defineFunction({
 
     // Next, prevent vertical misplacement when next to something tall.
     // This code resolves issue #1234
-    node = makeSpan(["thinbox"], [node], options);
-    return makeSpan(["mord", "vbox"], [node], options);
+    node = makeSpan(["katex-thinbox"], [node], options);
+    return makeSpan(["mord", "katex-vbox"], [node], options);
   },
   mathmlBuilder: (group, options) => {
     // mathllap, mathrlap, mathclap
@@ -12540,16 +12307,12 @@ defineFunction({
 defineFunction({
   type: "styling",
   names: ["\\(", "$"],
-  props: {
-    numArgs: 0,
-    allowedInText: true,
-    allowedInMath: false
-  },
+  numArgs: 0,
+  allowedInText: true,
+  allowedInMath: false,
   handler(_ref, args) {
-    let {
-      funcName,
-      parser
-    } = _ref;
+    let funcName = _ref.funcName,
+      parser = _ref.parser;
     const outerMode = parser.mode;
     parser.switchMode("math");
     const close = funcName === "\\(" ? "\\)" : "$";
@@ -12571,11 +12334,9 @@ defineFunction({
   type: "text",
   // Doesn't matter what this is.
   names: ["\\)", "\\]"],
-  props: {
-    numArgs: 0,
-    allowedInText: true,
-    allowedInMath: false
-  },
+  numArgs: 0,
+  allowedInText: true,
+  allowedInMath: false,
   handler(context, args) {
     throw new src_ParseError("Mismatched " + context.funcName);
   }
@@ -12603,14 +12364,10 @@ const chooseMathStyle = (group, options) => {
 defineFunction({
   type: "mathchoice",
   names: ["\\mathchoice"],
-  props: {
-    numArgs: 4,
-    primitive: true
-  },
+  numArgs: 4,
+  primitive: true,
   handler: (_ref, args) => {
-    let {
-      parser
-    } = _ref;
+    let parser = _ref.parser;
     return {
       type: "mathchoice",
       mode: parser.mode,
@@ -12922,14 +12679,10 @@ const singleCharBigOps = {
 defineFunction({
   type: "op",
   names: ["\\coprod", "\\bigvee", "\\bigwedge", "\\biguplus", "\\bigcap", "\\bigcup", "\\intop", "\\prod", "\\sum", "\\bigotimes", "\\bigoplus", "\\bigodot", "\\bigsqcup", "\\smallint", "\u220F", "\u2210", "\u2211", "\u22c0", "\u22c1", "\u22c2", "\u22c3", "\u2a00", "\u2a01", "\u2a02", "\u2a04", "\u2a06"],
-  props: {
-    numArgs: 0
-  },
+  numArgs: 0,
   handler: (_ref, args) => {
-    let {
-      parser,
-      funcName
-    } = _ref;
+    let parser = _ref.parser,
+      funcName = _ref.funcName;
     let fName = funcName;
     if (fName.length === 1) {
       fName = singleCharBigOps[fName];
@@ -12946,20 +12699,13 @@ defineFunction({
   htmlBuilder: op_htmlBuilder,
   mathmlBuilder: op_mathmlBuilder
 });
-
-// Note: calling defineFunction with a type that's already been defined only
-// works because the same htmlBuilder and mathmlBuilder are being used.
 defineFunction({
   type: "op",
   names: ["\\mathop"],
-  props: {
-    numArgs: 1,
-    primitive: true
-  },
+  numArgs: 1,
+  primitive: true,
   handler: (_ref2, args) => {
-    let {
-      parser
-    } = _ref2;
+    let parser = _ref2.parser;
     const body = args[0];
     return {
       type: "op",
@@ -12969,9 +12715,7 @@ defineFunction({
       symbol: false,
       body: ordargument(body)
     };
-  },
-  htmlBuilder: op_htmlBuilder,
-  mathmlBuilder: op_mathmlBuilder
+  }
 });
 
 // There are 2 flags for operators; whether they produce limits in
@@ -12990,14 +12734,10 @@ const singleCharIntegrals = {
 defineFunction({
   type: "op",
   names: ["\\arcsin", "\\arccos", "\\arctan", "\\arctg", "\\arcctg", "\\arg", "\\ch", "\\cos", "\\cosec", "\\cosh", "\\cot", "\\cotg", "\\coth", "\\csc", "\\ctg", "\\cth", "\\deg", "\\dim", "\\exp", "\\hom", "\\ker", "\\lg", "\\ln", "\\log", "\\sec", "\\sin", "\\sinh", "\\sh", "\\tan", "\\tanh", "\\tg", "\\th"],
-  props: {
-    numArgs: 0
-  },
+  numArgs: 0,
   handler(_ref3) {
-    let {
-      parser,
-      funcName
-    } = _ref3;
+    let parser = _ref3.parser,
+      funcName = _ref3.funcName;
     return {
       type: "op",
       mode: parser.mode,
@@ -13006,23 +12746,17 @@ defineFunction({
       symbol: false,
       name: funcName
     };
-  },
-  htmlBuilder: op_htmlBuilder,
-  mathmlBuilder: op_mathmlBuilder
+  }
 });
 
 // Limits, not symbols
 defineFunction({
   type: "op",
   names: ["\\det", "\\gcd", "\\inf", "\\lim", "\\max", "\\min", "\\Pr", "\\sup"],
-  props: {
-    numArgs: 0
-  },
+  numArgs: 0,
   handler(_ref4) {
-    let {
-      parser,
-      funcName
-    } = _ref4;
+    let parser = _ref4.parser,
+      funcName = _ref4.funcName;
     return {
       type: "op",
       mode: parser.mode,
@@ -13031,24 +12765,18 @@ defineFunction({
       symbol: false,
       name: funcName
     };
-  },
-  htmlBuilder: op_htmlBuilder,
-  mathmlBuilder: op_mathmlBuilder
+  }
 });
 
 // No limits, symbols
 defineFunction({
   type: "op",
   names: ["\\int", "\\iint", "\\iiint", "\\oint", "\\oiint", "\\oiiint", "\u222b", "\u222c", "\u222d", "\u222e", "\u222f", "\u2230"],
-  props: {
-    numArgs: 0,
-    allowedInArgument: true
-  },
+  numArgs: 0,
+  allowedInArgument: true,
   handler(_ref5) {
-    let {
-      parser,
-      funcName
-    } = _ref5;
+    let parser = _ref5.parser,
+      funcName = _ref5.funcName;
     let fName = funcName;
     if (fName.length === 1) {
       fName = singleCharIntegrals[fName];
@@ -13061,9 +12789,7 @@ defineFunction({
       symbol: true,
       name: fName
     };
-  },
-  htmlBuilder: op_htmlBuilder,
-  mathmlBuilder: op_mathmlBuilder
+  }
 });
 ;// ./src/functions/operatorname.ts
 
@@ -13188,14 +12914,10 @@ const operatorname_mathmlBuilder = (group, options) => {
 defineFunction({
   type: "operatorname",
   names: ["\\operatorname@", "\\operatornamewithlimits"],
-  props: {
-    numArgs: 1
-  },
+  numArgs: 1,
   handler: (_ref, args) => {
-    let {
-      parser,
-      funcName
-    } = _ref;
+    let parser = _ref.parser,
+      funcName = _ref.funcName;
     const body = args[0];
     return {
       type: "operatorname",
@@ -13236,13 +12958,9 @@ defineFunctionBuilders({
 defineFunction({
   type: "overline",
   names: ["\\overline"],
-  props: {
-    numArgs: 1
-  },
+  numArgs: 1,
   handler(_ref, args) {
-    let {
-      parser
-    } = _ref;
+    let parser = _ref.parser;
     const body = args[0];
     return {
       type: "overline",
@@ -13277,7 +12995,7 @@ defineFunction({
         size: defaultRuleThickness
       }]
     }, options);
-    return makeSpan(["mord", "overline"], [vlist], options);
+    return makeSpan(["mord", "katex-overline"], [vlist], options);
   },
   mathmlBuilder(group, options) {
     const operator = new MathNode("mo", [new TextNode("\u203e")]);
@@ -13297,14 +13015,10 @@ defineFunction({
 defineFunction({
   type: "phantom",
   names: ["\\phantom"],
-  props: {
-    numArgs: 1,
-    allowedInText: true
-  },
+  numArgs: 1,
+  allowedInText: true,
   handler: (_ref, args) => {
-    let {
-      parser
-    } = _ref;
+    let parser = _ref.parser;
     const body = args[0];
     return {
       type: "phantom",
@@ -13328,14 +13042,10 @@ defineMacro("\\hphantom", "\\smash{\\phantom{#1}}");
 defineFunction({
   type: "vphantom",
   names: ["\\vphantom"],
-  props: {
-    numArgs: 1,
-    allowedInText: true
-  },
+  numArgs: 1,
+  allowedInText: true,
   handler: (_ref2, args) => {
-    let {
-      parser
-    } = _ref2;
+    let parser = _ref2.parser;
     const body = args[0];
     return {
       type: "vphantom",
@@ -13344,8 +13054,8 @@ defineFunction({
     };
   },
   htmlBuilder: (group, options) => {
-    const inner = makeSpan(["inner"], [buildGroup(group.body, options.withPhantom())]);
-    const fix = makeSpan(["fix"], []);
+    const inner = makeSpan(["katex-inner"], [buildGroup(group.body, options.withPhantom())]);
+    const fix = makeSpan(["katex-fix"], []);
     return makeSpan(["mord", "rlap"], [inner, fix], options);
   },
   mathmlBuilder: (group, options) => {
@@ -13369,15 +13079,11 @@ defineFunction({
 defineFunction({
   type: "raisebox",
   names: ["\\raisebox"],
-  props: {
-    numArgs: 2,
-    argTypes: ["size", "hbox"],
-    allowedInText: true
-  },
+  numArgs: 2,
+  argTypes: ["size", "hbox"],
+  allowedInText: true,
   handler(_ref, args) {
-    let {
-      parser
-    } = _ref;
+    let parser = _ref.parser;
     const amount = assertNodeType(args[0], "size").value;
     const body = args[1];
     return {
@@ -13411,15 +13117,11 @@ defineFunction({
 defineFunction({
   type: "internal",
   names: ["\\relax"],
-  props: {
-    numArgs: 0,
-    allowedInText: true,
-    allowedInArgument: true
-  },
+  numArgs: 0,
+  allowedInText: true,
+  allowedInArgument: true,
   handler(_ref) {
-    let {
-      parser
-    } = _ref;
+    let parser = _ref.parser;
     return {
       type: "internal",
       mode: parser.mode
@@ -13435,17 +13137,13 @@ defineFunction({
 defineFunction({
   type: "rule",
   names: ["\\rule"],
-  props: {
-    numArgs: 2,
-    numOptionalArgs: 1,
-    allowedInText: true,
-    allowedInMath: true,
-    argTypes: ["size", "size", "size"]
-  },
+  numArgs: 2,
+  numOptionalArgs: 1,
+  allowedInText: true,
+  allowedInMath: true,
+  argTypes: ["size", "size", "size"],
   handler(_ref, args, optArgs) {
-    let {
-      parser
-    } = _ref;
+    let parser = _ref.parser;
     const shift = optArgs[0];
     const width = assertNodeType(args[0], "size");
     const height = assertNodeType(args[1], "size");
@@ -13459,7 +13157,7 @@ defineFunction({
   },
   htmlBuilder(group, options) {
     // Make an empty span for the rule
-    const rule = makeSpan(["mord", "rule"], [], options);
+    const rule = makeSpan(["mord", "katex-rule"], [], options);
 
     // Calculate the shift, width, and height of the rule, and account for units
     const width = calculateSize(group.width, options);
@@ -13515,7 +13213,7 @@ function sizingGroup(value, options, baseOptions) {
   // Add size-resetting classes to the inner list and set maxFontSize
   // manually. Handle nested size changes.
   for (let i = 0; i < inner.length; i++) {
-    const pos = inner[i].classes.indexOf("sizing");
+    const pos = inner[i].classes.indexOf("katex-sizing");
     if (pos < 0) {
       Array.prototype.push.apply(inner[i].classes, options.sizingClasses(baseOptions));
     } else if (inner[i].classes[pos + 1] === "reset-size" + options.size) {
@@ -13540,16 +13238,12 @@ const sizing_htmlBuilder = (group, options) => {
 defineFunction({
   type: "sizing",
   names: sizeFuncs,
-  props: {
-    numArgs: 0,
-    allowedInText: true
-  },
+  numArgs: 0,
+  allowedInText: true,
   handler: (_ref, args) => {
-    let {
-      breakOnTokenText,
-      funcName,
-      parser
-    } = _ref;
+    let breakOnTokenText = _ref.breakOnTokenText,
+      funcName = _ref.funcName,
+      parser = _ref.parser;
     const body = parser.parseExpression(false, breakOnTokenText);
     return {
       type: "sizing",
@@ -13585,15 +13279,11 @@ defineFunction({
 defineFunction({
   type: "smash",
   names: ["\\smash"],
-  props: {
-    numArgs: 1,
-    numOptionalArgs: 1,
-    allowedInText: true
-  },
+  numArgs: 1,
+  numOptionalArgs: 1,
+  allowedInText: true,
   handler: (_ref, args, optArgs) => {
-    let {
-      parser
-    } = _ref;
+    let parser = _ref.parser;
     let smashHeight = false;
     let smashDepth = false;
     const tbArg = optArgs[0] && assertNodeType(optArgs[0], "ordgroup");
@@ -13641,7 +13331,7 @@ defineFunction({
     }
     if (group.smashHeight && group.smashDepth) {
       // Symmetric \smash can stay in inline layout.
-      return makeSpan(["mord", "smash"], [node], options);
+      return makeSpan(["mord", "katex-smash"], [node], options);
     }
 
     // In order to influence makeVList for asymmetric smashing, we have to
@@ -13696,14 +13386,10 @@ defineFunction({
 defineFunction({
   type: "sqrt",
   names: ["\\sqrt"],
-  props: {
-    numArgs: 1,
-    numOptionalArgs: 1
-  },
+  numArgs: 1,
+  numOptionalArgs: 1,
   handler(_ref, args, optArgs) {
-    let {
-      parser
-    } = _ref;
+    let parser = _ref.parser;
     const index = optArgs[0];
     const body = args[0];
     return {
@@ -13741,11 +13427,10 @@ defineFunction({
     const minDelimiterHeight = inner.height + inner.depth + lineClearance + theta;
 
     // Create a sqrt SVG of the required minimum size
-    const {
-      span: img,
-      ruleWidth,
-      advanceWidth
-    } = makeSqrtImage(minDelimiterHeight, options);
+    const _makeSqrtImage = makeSqrtImage(minDelimiterHeight, options),
+      img = _makeSqrtImage.span,
+      ruleWidth = _makeSqrtImage.ruleWidth,
+      advanceWidth = _makeSqrtImage.advanceWidth;
     const delimDepth = img.height - ruleWidth;
 
     // Adjust the clearance based on the delimiter size
@@ -13799,15 +13484,13 @@ defineFunction({
       }, options);
       // Add a class surrounding it so we can add on the appropriate
       // kerning
-      const rootVListWrap = makeSpan(["root"], [rootVList]);
+      const rootVListWrap = makeSpan(["katex-root"], [rootVList]);
       return makeSpan(["mord", "sqrt"], [rootVListWrap, body], options);
     }
   },
   mathmlBuilder(group, options) {
-    const {
-      body,
-      index
-    } = group;
+    const body = group.body,
+      index = group.index;
     return index ? new MathNode("mroot", [buildMathML_buildGroup(body, options), buildMathML_buildGroup(index, options)]) : new MathNode("msqrt", [buildMathML_buildGroup(body, options)]);
   }
 });
@@ -13829,17 +13512,13 @@ function isStyleStr(s) {
 defineFunction({
   type: "styling",
   names: ["\\displaystyle", "\\textstyle", "\\scriptstyle", "\\scriptscriptstyle"],
-  props: {
-    numArgs: 0,
-    allowedInText: true,
-    primitive: true
-  },
+  numArgs: 0,
+  allowedInText: true,
+  primitive: true,
   handler(_ref, args) {
-    let {
-      breakOnTokenText,
-      funcName,
-      parser
-    } = _ref;
+    let breakOnTokenText = _ref.breakOnTokenText,
+      funcName = _ref.funcName,
+      parser = _ref.parser;
     // parse out the implicit body
     const body = parser.parseExpression(true, breakOnTokenText);
 
@@ -13947,11 +13626,9 @@ defineFunctionBuilders({
     if (builderDelegate) {
       return builderDelegate(group, options);
     }
-    const {
-      base: valueBase,
-      sup: valueSup,
-      sub: valueSub
-    } = group;
+    const valueBase = group.base,
+      valueSup = group.sup,
+      valueSub = group.sub;
     const base = buildGroup(valueBase, options);
     let supm;
     let subm;
@@ -14171,7 +13848,7 @@ const defaultVariant = {
 defineFunctionBuilders({
   type: "mathord",
   htmlBuilder(group, options) {
-    return makeOrd(group, options, "mathord");
+    return makeOrd(group, options);
   },
   mathmlBuilder(group, options) {
     const node = new MathNode("mi", [makeText(group.text, group.mode, options)]);
@@ -14185,7 +13862,7 @@ defineFunctionBuilders({
 defineFunctionBuilders({
   type: "textord",
   htmlBuilder(group, options) {
-    return makeOrd(group, options, "textord");
+    return makeOrd(group, options);
   },
   mathmlBuilder(group, options) {
     const text = makeText(group.text, group.mode, options);
@@ -14213,57 +13890,50 @@ defineFunctionBuilders({
 
 
 // A map of CSS-based spacing functions to their CSS class.
-const cssSpace = {
-  "\\nobreak": "nobreak",
-  "\\allowbreak": "allowbreak"
-};
+const cssSpace = new Map([["\\nobreak", "nobreak"], ["\\allowbreak", "allowbreak"]]);
 
 // A lookup table to determine whether a spacing function/symbol should be
 // treated like a regular space character.  If a symbol or command is a key
 // in this table, then it should be a regular space character.  Furthermore,
 // the associated value may have a `className` specifying an extra CSS class
 // to add to the created `span`.
-const regularSpace = {
-  " ": {},
-  "\\ ": {},
-  "~": {
-    className: "nobreak"
-  },
-  "\\space": {},
-  "\\nobreakspace": {
-    className: "nobreak"
-  }
-};
+const regularSpace = new Map([[" ", {}], ["\\ ", {}], ["~", {
+  className: "nobreak"
+}], ["\\space", {}], ["\\nobreakspace", {
+  className: "nobreak"
+}]]);
 
 // ParseNode<"spacing"> created in Parser.js from the "spacing" symbol Groups in
 // src/symbols.js.
 defineFunctionBuilders({
   type: "spacing",
   htmlBuilder(group, options) {
-    if (regularSpace.hasOwnProperty(group.text)) {
-      const className = regularSpace[group.text].className || "";
+    const regularSpaceItem = regularSpace.get(group.text);
+    const cssSpaceClass = cssSpace.get(group.text);
+    if (regularSpaceItem) {
+      const className = regularSpaceItem.className || "";
       // Spaces are generated by adding an actual space. Each of these
       // things has an entry in the symbols table, so these will be turned
       // into appropriate outputs.
       if (group.mode === "text") {
-        const ord = makeOrd(group, options, "textord");
+        const ord = makeOrd(group, options);
         ord.classes.push(className);
         return ord;
       } else {
         return makeSpan(["mspace", className], [mathsym(group.text, group.mode, options)], options);
       }
-    } else if (cssSpace.hasOwnProperty(group.text)) {
+    } else if (cssSpaceClass) {
       // Spaces based on just a CSS class.
-      return makeSpan(["mspace", cssSpace[group.text]], [], options);
+      return makeSpan(["mspace", cssSpaceClass], [], options);
     } else {
       throw new src_ParseError("Unknown type of space \"" + group.text + "\"");
     }
   },
   mathmlBuilder(group, options) {
     let node;
-    if (regularSpace.hasOwnProperty(group.text)) {
+    if (regularSpace.has(group.text)) {
       node = new MathNode("mtext", [new TextNode("\u00a0")]);
-    } else if (cssSpace.hasOwnProperty(group.text)) {
+    } else if (cssSpace.has(group.text)) {
       // CSS-based MathML spaces (\nobreak, \allowbreak) are ignored
       return new MathNode("mspace");
     } else {
@@ -14341,17 +14011,13 @@ defineFunction({
   "\\textbf", "\\textmd",
   // Font Shapes
   "\\textit", "\\textup", "\\emph"],
-  props: {
-    numArgs: 1,
-    argTypes: ["text"],
-    allowedInArgument: true,
-    allowedInText: true
-  },
+  numArgs: 1,
+  argTypes: ["text"],
+  allowedInArgument: true,
+  allowedInText: true,
   handler(_ref, args) {
-    let {
-      parser,
-      funcName
-    } = _ref;
+    let parser = _ref.parser,
+      funcName = _ref.funcName;
     const body = args[0];
     return {
       type: "text",
@@ -14379,14 +14045,10 @@ defineFunction({
 defineFunction({
   type: "underline",
   names: ["\\underline"],
-  props: {
-    numArgs: 1,
-    allowedInText: true
-  },
+  numArgs: 1,
+  allowedInText: true,
   handler(_ref, args) {
-    let {
-      parser
-    } = _ref;
+    let parser = _ref.parser;
     return {
       type: "underline",
       mode: parser.mode,
@@ -14420,7 +14082,7 @@ defineFunction({
         elem: innerGroup
       }]
     }, options);
-    return makeSpan(["mord", "underline"], [vlist], options);
+    return makeSpan(["mord", "katex-underline"], [vlist], options);
   },
   mathmlBuilder(group, options) {
     const operator = new MathNode("mo", [new TextNode("\u203e")]);
@@ -14442,16 +14104,12 @@ defineFunction({
 defineFunction({
   type: "vcenter",
   names: ["\\vcenter"],
-  props: {
-    numArgs: 1,
-    argTypes: ["original"],
-    // In LaTeX, \vcenter can act only on a box.
-    allowedInText: false
-  },
+  numArgs: 1,
+  argTypes: ["original"],
+  // In LaTeX, \vcenter can act only on a box.
+  allowedInText: false,
   handler(_ref, args) {
-    let {
-      parser
-    } = _ref;
+    let parser = _ref.parser;
     return {
       type: "vcenter",
       mode: parser.mode,
@@ -14488,10 +14146,8 @@ defineFunction({
 defineFunction({
   type: "verb",
   names: ["\\verb"],
-  props: {
-    numArgs: 0,
-    allowedInText: true
-  },
+  numArgs: 0,
+  allowedInText: true,
   handler(context, args, optArgs) {
     // \verb and \verb* are dealt with directly in Parser.js.
     // If we end up here, it's because of a failure to match the two delimiters
@@ -14742,13 +14398,11 @@ class Namespace {
       throw new src_ParseError("Unbalanced namespace destruction: attempt " + "to pop global namespace; please report this as a bug");
     }
     const undefs = this.undefStack.pop();
-    for (const undef in undefs) {
-      if (undefs.hasOwnProperty(undef)) {
-        if (undefs[undef] == null) {
-          delete this.current[undef];
-        } else {
-          this.current[undef] = undefs[undef];
-        }
+    for (const key of Object.keys(undefs)) {
+      if (undefs[key] === undefined) {
+        delete this.current[key];
+      } else {
+        this.current[key] = undefs[key];
       }
     }
   }
@@ -14768,7 +14422,7 @@ class Namespace {
    * `get(name) != null`.
    */
   has(name) {
-    return this.current.hasOwnProperty(name) || this.builtins.hasOwnProperty(name);
+    return Object.prototype.hasOwnProperty.call(this.current, name) || Object.prototype.hasOwnProperty.call(this.builtins, name);
   }
 
   /**
@@ -14780,7 +14434,7 @@ class Namespace {
    * `if (namespace.has(...))`.
    */
   get(name) {
-    if (this.current.hasOwnProperty(name)) {
+    if (Object.prototype.hasOwnProperty.call(this.current, name)) {
       return this.current[name];
     } else {
       return this.builtins[name];
@@ -14814,7 +14468,7 @@ class Namespace {
       // unless an undo is already in place, in which case that older
       // value is the correct one.
       const top = this.undefStack[this.undefStack.length - 1];
-      if (top && !top.hasOwnProperty(name)) {
+      if (top && !Object.prototype.hasOwnProperty.call(top, name)) {
         top[name] = this.current[name];
       }
     }
@@ -15925,16 +15579,14 @@ class MacroExpander {
         return null;
       }
       start = this.popToken(); // don't include [ in tokens
-      ({
-        tokens,
-        end
-      } = this.consumeArg(["]"]));
+      var _this$consumeArg = this.consumeArg(["]"]);
+      tokens = _this$consumeArg.tokens;
+      end = _this$consumeArg.end;
     } else {
-      ({
-        tokens,
-        start,
-        end
-      } = this.consumeArg());
+      var _this$consumeArg2 = this.consumeArg();
+      tokens = _this$consumeArg2.tokens;
+      start = _this$consumeArg2.start;
+      end = _this$consumeArg2.end;
     }
 
     // indicate the end of an argument
@@ -16245,7 +15897,7 @@ class MacroExpander {
    * `implicitCommands`.
    */
   isDefined(name) {
-    return this.macros.has(name) || src_functions.hasOwnProperty(name) || src_symbols.math.hasOwnProperty(name) || src_symbols.text.hasOwnProperty(name) || implicitCommands.hasOwnProperty(name);
+    return this.macros.has(name) || Object.prototype.hasOwnProperty.call(src_functions, name) || Object.prototype.hasOwnProperty.call(src_symbols.math, name) || Object.prototype.hasOwnProperty.call(src_symbols.text, name) || Object.prototype.hasOwnProperty.call(implicitCommands, name);
   }
 
   /**
@@ -16253,7 +15905,10 @@ class MacroExpander {
    */
   isExpandable(name) {
     const macro = this.macros.get(name);
-    return macro != null ? typeof macro === "string" || typeof macro === "function" || !macro.unexpandable : src_functions.hasOwnProperty(name) && !src_functions[name].primitive;
+    if (macro != null) {
+      return typeof macro === "string" || typeof macro === "function" || !macro.unexpandable;
+    }
+    return Object.prototype.hasOwnProperty.call(src_functions, name) && !src_functions[name].primitive;
   }
 }
 ;// ./src/unicodeSupOrSub.ts
@@ -17077,7 +16732,7 @@ class Parser {
     const base = this.parseGroup("atom", breakOnTokenText);
 
     // Internal nodes (e.g. \relax) cannot support super/subscripts.
-    // Instead we will pick up super/subscripts with blank base next round.
+    // Instead, we will pick up super/subscripts with blank base next round.
     if ((base == null ? void 0 : base.type) === "internal") {
       return base;
     }
@@ -17086,9 +16741,6 @@ class Parser {
     if (this.mode === "text") {
       return base;
     }
-
-    // Note that base may be empty (i.e. null) at this point.
-
     let superscript;
     let subscript;
     while (true) {
@@ -17100,8 +16752,7 @@ class Parser {
       if (lex.text === "\\limits" || lex.text === "\\nolimits") {
         // We got a limit control
         if (base && base.type === "op") {
-          const limits = lex.text === "\\limits";
-          base.limits = limits;
+          base.limits = lex.text === "\\limits";
           base.alwaysHandleSupSub = true;
         } else if (base && base.type === "operatorname") {
           if (base.alwaysHandleSupSub) {
@@ -17198,15 +16849,28 @@ class Parser {
 
     // Base must be set if superscript or subscript are set per logic above,
     // but need to check here for type check to pass.
-    if (superscript || subscript) {
-      // If we got either a superscript or subscript, create a supsub
+    if (superscript && subscript) {
       return {
         type: "supsub",
         mode: this.mode,
-        base: base,
+        base,
         sup: superscript,
         sub: subscript
       };
+    } else if (superscript) {
+      return {
+        type: "supsub",
+        mode: this.mode,
+        base,
+        sup: superscript
+      };
+    } else if (subscript) {
+      return {
+        type: "supsub",
+        mode: this.mode,
+        base,
+        sub: subscript
+      };
     } else {
       // Otherwise return the original body
       return base;
@@ -17228,15 +16892,16 @@ class Parser {
 
     if (name && name !== "atom" && !funcData.allowedInArgument) {
       throw new src_ParseError("Got function '" + func + "' with no arguments" + (name ? " as " + name : ""), token);
+      // Treat undefined allowedInText as false.
     } else if (this.mode === "text" && !funcData.allowedInText) {
       throw new src_ParseError("Can't use function '" + func + "' in text mode", token);
+      // Treat undefined allowedInMath as true.
     } else if (this.mode === "math" && funcData.allowedInMath === false) {
       throw new src_ParseError("Can't use function '" + func + "' in math mode", token);
     }
-    const {
-      args,
-      optArgs
-    } = this.parseArguments(func, funcData);
+    const _this$parseArguments = this.parseArguments(func, funcData),
+      args = _this$parseArguments.args,
+      optArgs = _this$parseArguments.optArgs;
     return this.callFunction(func, args, optArgs, token, breakOnTokenText);
   }
 
@@ -17264,7 +16929,9 @@ class Parser {
   parseArguments(func,
   // Should look like "\name" or "\begin{name}".
   funcData) {
-    const totalArgs = funcData.numArgs + funcData.numOptionalArgs;
+    var _funcData$numOptional;
+    const numOptionalArgs = (_funcData$numOptional = funcData.numOptionalArgs) != null ? _funcData$numOptional : 0;
+    const totalArgs = funcData.numArgs + numOptionalArgs;
     if (totalArgs === 0) {
       return {
         args: [],
@@ -17274,8 +16941,9 @@ class Parser {
     const args = [];
     const optArgs = [];
     for (let i = 0; i < totalArgs; i++) {
-      let argType = funcData.argTypes && funcData.argTypes[i];
-      const isOptional = i < funcData.numOptionalArgs;
+      var _funcData$argTypes;
+      let argType = (_funcData$argTypes = funcData.argTypes) == null ? void 0 : _funcData$argTypes[i];
+      const isOptional = i < numOptionalArgs;
       if ("primitive" in funcData && funcData.primitive && argType == null ||
       // \sqrt expands into primitive if optional argument doesn't exist
       funcData.type === "sqrt" && i === 1 && optArgs[0] == null) {
@@ -17328,7 +16996,7 @@ class Parser {
         }
       case "raw":
         {
-          const token = this.parseStringGroup("raw", optional);
+          const token = this.parseStringGroup(optional);
           return token != null ? {
             type: "raw",
             mode: "text",
@@ -17347,7 +17015,6 @@ class Parser {
           return group;
         }
       case "original":
-      case null:
       case undefined:
         return this.parseArgumentGroup(optional);
       default:
@@ -17368,9 +17035,7 @@ class Parser {
    * Parses a group, essentially returning the string formed by the
    * brace-enclosed tokens plus some position information.
    */
-  parseStringGroup(modeName,
-  // Used to describe the mode in error messages.
-  optional) {
+  parseStringGroup(optional) {
     const argToken = this.gullet.scanArgument(optional);
     if (argToken == null) {
       return null;
@@ -17412,7 +17077,7 @@ class Parser {
    * Parses a color description.
    */
   parseColorGroup(optional) {
-    const res = this.parseStringGroup("color", optional);
+    const res = this.parseStringGroup(optional);
     if (res == null) {
       return null;
     }
@@ -17445,7 +17110,7 @@ class Parser {
     if (!optional && this.gullet.future().text !== "{") {
       res = this.parseRegexGroup(/^[-+]? *(?:$|\d+|\d+\.\d*|\.\d*) *[a-z]{0,2} *$/, "size");
     } else {
-      res = this.parseStringGroup("size", optional);
+      res = this.parseStringGroup(optional);
     }
     if (!res) {
       return null;
@@ -17484,7 +17149,7 @@ class Parser {
   parseUrlGroup(optional) {
     this.gullet.lexer.setCatcode("%", 13); // active character
     this.gullet.lexer.setCatcode("~", 12); // other character
-    const res = this.parseStringGroup("url", optional);
+    const res = this.parseStringGroup(optional);
     this.gullet.lexer.setCatcode("%", 14); // comment character
     this.gullet.lexer.setCatcode("~", 13); // active character
     if (res == null) {
@@ -17570,7 +17235,7 @@ class Parser {
       // If there exists a function with this name, parse the function.
       // Otherwise, just return a nucleus
       result = this.parseFunction(breakOnTokenText, name) || this.parseSymbol();
-      if (result == null && text[0] === "\\" && !implicitCommands.hasOwnProperty(text)) {
+      if (result == null && text[0] === "\\" && !Object.prototype.hasOwnProperty.call(implicitCommands, text)) {
         if (this.settings.throwOnError) {
           throw new src_ParseError("Undefined control sequence: " + text, firstToken);
         }
@@ -17663,7 +17328,7 @@ class Parser {
     }
     // At this point, we should have a symbol, possibly with accents.
     // First expand any accented base symbol according to unicodeSymbols.
-    if (unicodeSymbols.hasOwnProperty(text[0]) && !src_symbols[this.mode][text[0]]) {
+    if (Object.prototype.hasOwnProperty.call(unicodeSymbols, text[0]) && !src_symbols[this.mode][text[0]]) {
       // This behavior is not strict (XeTeX-compatible) in math mode.
       if (this.settings.strict && this.mode === "math") {
         this.settings.reportNonstrict("unicodeTextInMathMode", "Accented Unicode text character \"" + text[0] + "\" used in " + "math mode", nucleus);
@@ -17759,11 +17424,6 @@ class Parser {
 }
 Parser.endOfExpression = new Set(["}", "\\endgroup", "\\end", "\\right", "&"]);
 ;// ./src/parseTree.ts
-/**
- * Provides a single function for parsing an expression using a Parser
- * TODO(emily): Remove this
- */
-
 
 
 
@@ -17899,7 +17559,7 @@ const renderToHTMLTree = function (expression, options) {
     return renderError(error, expression, settings);
   }
 };
-const version = "0.16.47";
+const version = "0.18.0";
 const __domTree = {
   Span: Span,
   Anchor: Anchor,