katex 0.16.44 → 0.16.46

package/dist/katex.js

@@ -49,10 +49,6 @@ __webpack_require__.d(__webpack_exports__, {
  * about where in the source string the problem occurred.
  */
 class ParseError extends Error {
-  // Error start position based on passed-in Token or ParseNode.
-
-  // Length of affected text based on passed-in Token or ParseNode.
-
   // The underlying error message without any context added.
 
   constructor(message,
@@ -97,6 +93,11 @@ class ParseError extends Error {
     }
     super(error);
     this.name = "ParseError";
+    this.position = void 0;
+    // Error start position based on passed-in Token or ParseNode.
+    this.length = void 0;
+    // Length of affected text based on passed-in Token or ParseNode.
+    this.rawMessage = void 0;
     Object.setPrototypeOf(this, ParseError.prototype);
     this.position = start;
     if (start != null && end != null) {
@@ -171,7 +172,6 @@ const protocolFromUrl = url => {
   // Check for possible leading protocol.
   // https://url.spec.whatwg.org/#url-parsing strips leading whitespace
   // (U+20) or C0 control (U+00-U+1F) characters.
-  // eslint-disable-next-line no-control-regex
   const protocol = /^[\x00-\x20]*([^\\/#?]*?)(:|&#0*58|&#x0*3a|&colon)/i.exec(url);
   if (!protocol) {
     return "_relative";
@@ -197,6 +197,13 @@ const protocolFromUrl = url => {
 
 
 
+
+/**
+ * Union of all values that appear as schema defaults, cliDefaults, or
+ * cliProcessor return values.  StrictFunction / TrustFunction are
+ * option-value types, not default/schema values, so they are excluded.
+ */
+
 // TODO: automatically generate documentation
 // TODO: check all properties on Settings exist
 // TODO: check the type of a property on Settings matches
@@ -290,16 +297,11 @@ const SETTINGS_SCHEMA = {
     cli: false
   }
 };
-function getDefaultValue(schema) {
-  if ("default" in schema) {
-    return schema.default;
-  }
-  const type = schema.type;
-  const defaultType = Array.isArray(type) ? type[0] : type;
-  if (typeof defaultType !== 'string') {
-    return defaultType.enum[0];
+function getImplicitDefault(type) {
+  if (typeof type !== 'string') {
+    return type.enum[0];
   }
-  switch (defaultType) {
+  switch (type) {
     case 'boolean':
       return false;
     case 'string':
@@ -308,8 +310,21 @@ function getDefaultValue(schema) {
       return 0;
     case 'object':
       return {};
+    default:
+      throw new Error("Unexpected schema type; settings must declare an explicit default.");
   }
 }
+function getDefaultValue(schema) {
+  if (schema.default !== undefined) {
+    return schema.default;
+  }
+  const type = Array.isArray(schema.type) ? schema.type[0] : schema.type;
+  return getImplicitDefault(type);
+}
+function applySetting(target, prop, options, schema) {
+  const optionValue = options[prop];
+  target[prop] = optionValue !== undefined ? schema.processor ? schema.processor(optionValue) : optionValue : getDefaultValue(schema);
+}
 
 /**
  * The main Settings object
@@ -326,13 +341,28 @@ class Settings {
     if (options === void 0) {
       options = {};
     }
+    this.displayMode = void 0;
+    this.output = void 0;
+    this.leqno = void 0;
+    this.fleqn = void 0;
+    this.throwOnError = void 0;
+    this.errorColor = void 0;
+    this.macros = void 0;
+    this.minRuleThickness = void 0;
+    this.colorIsTextColor = void 0;
+    this.strict = void 0;
+    this.trust = void 0;
+    this.maxSize = void 0;
+    this.maxExpand = void 0;
+    this.globalGroup = void 0;
     // allow null options
     options = options || {};
     for (const prop of Object.keys(SETTINGS_SCHEMA)) {
       const schema = SETTINGS_SCHEMA[prop];
-      const optionValue = options[prop];
-      // TODO: validate options
-      this[prop] = optionValue !== undefined ? schema.processor ? schema.processor(optionValue) : optionValue : getDefaultValue(schema);
+      if (schema) {
+        // TODO: validate options
+        applySetting(this, prop, options, schema);
+      }
     }
   }
 
@@ -429,6 +459,9 @@ class Settings {
  */
 class Style {
   constructor(id, size, cramped) {
+    this.id = void 0;
+    this.size = void 0;
+    this.cramped = void 0;
     this.id = id;
     this.size = size;
     this.cramped = cramped;
@@ -640,6 +673,18 @@ function supportedCodepoint(codepoint) {
 
 // In all paths below, the viewBox-to-em scale is 1000:1.
 
+// Second Brush Stroke
+//    Low resolution monitors struggle to display images in fine detail.
+//    So browsers apply anti-aliasing. A long straight arrow shaft therefore
+//    will sometimes appear as if it has a blurred edge.
+
+//    To mitigate this, these SVG files contain a second "brush-stroke" on the
+//    arrow shafts. That is, a second long thin rectangular SVG path has been
+//    written directly on top of each arrow shaft. This reinforcement causes
+//    some of the screen pixels to display as black instead of the anti-aliased
+//    gray pixel that a  single path would generate. So we get arrow shafts
+//    whose edges appear to be sharper.
+const doubleBrushStroke = svgPath => svgPath + " " + svgPath;
 const hLinePad = 80; // padding above a sqrt vinculum. Prevents image cropping.
 
 // The vinculum of a \sqrt can be made thicker by a KaTeX rendering option.
@@ -720,23 +765,23 @@ const innerPath = function (name, height) {
   // The inner part of stretchy tall delimiters
   switch (name) {
     case "\u239c":
-      return "M291 0 H417 V" + height + " H291z M291 0 H417 V" + height + " H291z";
+      return doubleBrushStroke("M291 0 H417 V" + height + " H291z");
     case "\u2223":
-      return "M145 0 H188 V" + height + " H145z M145 0 H188 V" + height + " H145z";
+      return doubleBrushStroke("M145 0 H188 V" + height + " H145z");
     case "\u2225":
-      return "M145 0 H188 V" + height + " H145z M145 0 H188 V" + height + " H145z" + ("M367 0 H410 V" + height + " H367z M367 0 H410 V" + height + " H367z");
+      return doubleBrushStroke("M145 0 H188 V" + height + " H145z") + doubleBrushStroke("M367 0 H410 V" + height + " H367z");
     case "\u239f":
-      return "M457 0 H583 V" + height + " H457z M457 0 H583 V" + height + " H457z";
+      return doubleBrushStroke("M457 0 H583 V" + height + " H457z");
     case "\u23a2":
-      return "M319 0 H403 V" + height + " H319z M319 0 H403 V" + height + " H319z";
+      return doubleBrushStroke("M319 0 H403 V" + height + " H319z");
     case "\u23a5":
-      return "M263 0 H347 V" + height + " H263z M263 0 H347 V" + height + " H263z";
+      return doubleBrushStroke("M263 0 H347 V" + height + " H263z");
     case "\u23aa":
-      return "M384 0 H504 V" + height + " H384z M384 0 H504 V" + height + " H384z";
+      return doubleBrushStroke("M384 0 H504 V" + height + " H384z");
     case "\u23d0":
-      return "M312 0 H355 V" + height + " H312z M312 0 H355 V" + height + " H312z";
+      return doubleBrushStroke("M312 0 H355 V" + height + " H312z");
     case "\u2016":
-      return "M257 0 H300 V" + height + " H257z M257 0 H300 V" + height + " H257z" + ("M478 0 H521 V" + height + " H478z M478 0 H521 V" + height + " H478z");
+      return doubleBrushStroke("M257 0 H300 V" + height + " H257z") + doubleBrushStroke("M478 0 H521 V" + height + " H478z");
     default:
       return "";
   }
@@ -761,13 +806,13 @@ const path = {
   leftharpoondownplus: "M7 435c-4 4-6.3 8.7-7 14 0 5.3.7 9 2 11s5.3 5.3 12\n 10c90.7 54 156 130 196 228 3.3 10.7 6.3 16.3 9 17 2 .7 5 1 9 1h5c10.7 0 16.7\n-2 18-6 2-2.7 1-9.7-3-21-32-87.3-82.7-157.7-152-211l-3-3h399907v-40H7zm93 0\nv40h399900v-40zM0 241v40h399900v-40zm0 0v40h399900v-40z",
   // hook is from glyph U+21A9 in font KaTeX Main
   lefthook: "M400000 281 H103s-33-11.2-61-33.5S0 197.3 0 164s14.2-61.2 42.5\n-83.5C70.8 58.2 104 47 142 47 c16.7 0 25 6.7 25 20 0 12-8.7 18.7-26 20-40 3.3\n-68.7 15.7-86 37-10 12-15 25.3-15 40 0 22.7 9.8 40.7 29.5 54 19.7 13.3 43.5 21\n 71.5 23h399859zM103 281v-40h399897v40z",
-  leftlinesegment: "M40 281 V428 H0 V94 H40 V241 H400000 v40z\nM40 281 V428 H0 V94 H40 V241 H400000 v40z",
-  leftbracketunder: "M0 0 h120 V290 H399995 v120 H0z\nM0 0 h120 V290 H399995 v120 H0z",
-  leftbracketover: "M0 440 h120 V150 H399995 v-120 H0z\nM0 440 h120 V150 H399995 v-120 H0z",
-  leftmapsto: "M40 281 V448H0V74H40V241H400000v40z\nM40 281 V448H0V74H40V241H400000v40z",
+  leftlinesegment: doubleBrushStroke("M40 281 V428 H0 V94 H40 V241 H400000 v40z"),
+  leftbracketunder: doubleBrushStroke("M0 0 h120 V290 H399995 v120 H0z"),
+  leftbracketover: doubleBrushStroke("M0 440 h120 V150 H399995 v-120 H0z"),
+  leftmapsto: doubleBrushStroke("M40 281 V448H0V74H40V241H400000v40z"),
   // tofrom is from glyph U+21C4 in font KaTeX AMS Regular
   leftToFrom: "M0 147h400000v40H0zm0 214c68 40 115.7 95.7 143 167h22c15.3 0 23\n-.3 23-1 0-1.3-5.3-13.7-16-37-18-35.3-41.3-69-70-101l-7-8h399905v-40H95l7-8\nc28.7-32 52-65.7 70-101 10.7-23.3 16-35.7 16-37 0-.7-7.7-1-23-1h-22C115.7 265.3\n 68 321 0 361zm0-174v-40h399900v40zm100 154v40h399900v-40z",
-  longequal: "M0 50 h400000 v40H0z m0 194h40000v40H0z\nM0 50 h400000 v40H0z m0 194h40000v40H0z",
+  longequal: doubleBrushStroke("M0 50 h400000 v40H0z m0 194h40000v40H0z"),
   midbrace: "M200428 334\nc-100.7-8.3-195.3-44-280-108-55.3-42-101.7-93-139-153l-9-14c-2.7 4-5.7 8.7-9 14\n-53.3 86.7-123.7 153-211 199-66.7 36-137.3 56.3-212 62H0V214h199568c178.3-11.7\n 311.7-78.3 403-201 6-8 9.7-12 11-12 .7-.7 6.7-1 18-1s17.3.3 18 1c1.3 0 5 4 11\n 12 44.7 59.3 101.3 106.3 170 141s145.3 54.3 229 60h199572v120z",
   midbraceunder: "M199572 214\nc100.7 8.3 195.3 44 280 108 55.3 42 101.7 93 139 153l9 14c2.7-4 5.7-8.7 9-14\n 53.3-86.7 123.7-153 211-199 66.7-36 137.3-56.3 212-62h199568v120H200432c-178.3\n 11.7-311.7 78.3-403 201-6 8-9.7 12-11 12-.7.7-6.7 1-18 1s-17.3-.3-18-1c-1.3 0\n-5-4-11-12-44.7-59.3-101.3-106.3-170-141s-145.3-54.3-229-60H0V214z",
   oiintSize1: "M512.6 71.6c272.6 0 320.3 106.8 320.3 178.2 0 70.8-47.7 177.6\n-320.3 177.6S193.1 320.6 193.1 249.8c0-71.4 46.9-178.2 319.5-178.2z\nm368.1 178.2c0-86.4-60.9-215.4-368.1-215.4-306.4 0-367.3 129-367.3 215.4 0 85.8\n60.9 214.8 367.3 214.8 307.2 0 368.1-129 368.1-214.8z",
@@ -784,9 +829,9 @@ const path = {
   rightharpoondown: "M399747 511c0 7.3 6.7 11 20 11 8 0 13-.8 15-2.5s4.7-6.8\n 8-15.5c40-94 99.3-166.3 178-217 13.3-8 20.3-12.3 21-13 5.3-3.3 8.5-5.8 9.5\n-7.5 1-1.7 1.5-5.2 1.5-10.5s-2.3-10.3-7-15H0v40h399908c-34 25.3-64.7 57-92 95\n-27.3 38-48.7 77.7-64 119-3.3 8.7-5 14-5 16zM0 241v40h399900v-40z",
   rightharpoondownplus: "M399747 705c0 7.3 6.7 11 20 11 8 0 13-.8\n 15-2.5s4.7-6.8 8-15.5c40-94 99.3-166.3 178-217 13.3-8 20.3-12.3 21-13 5.3-3.3\n 8.5-5.8 9.5-7.5 1-1.7 1.5-5.2 1.5-10.5s-2.3-10.3-7-15H0v40h399908c-34 25.3\n-64.7 57-92 95-27.3 38-48.7 77.7-64 119-3.3 8.7-5 14-5 16zM0 435v40h399900v-40z\nm0-194v40h400000v-40zm0 0v40h400000v-40z",
   righthook: "M399859 241c-764 0 0 0 0 0 40-3.3 68.7-15.7 86-37 10-12 15-25.3\n 15-40 0-22.7-9.8-40.7-29.5-54-19.7-13.3-43.5-21-71.5-23-17.3-1.3-26-8-26-20 0\n-13.3 8.7-20 26-20 38 0 71 11.2 99 33.5 0 0 7 5.6 21 16.7 14 11.2 21 33.5 21\n 66.8s-14 61.2-42 83.5c-28 22.3-61 33.5-99 33.5L0 241z M0 281v-40h399859v40z",
-  rightlinesegment: "M399960 241 V94 h40 V428 h-40 V281 H0 v-40z\nM399960 241 V94 h40 V428 h-40 V281 H0 v-40z",
-  rightbracketunder: "M399995 0 h-120 V290 H0 v120 H400000z\nM399995 0 h-120 V290 H0 v120 H400000z",
-  rightbracketover: "M399995 440 h-120 V150 H0 v-120 H399995z\nM399995 440 h-120 V150 H0 v-120 H399995z",
+  rightlinesegment: doubleBrushStroke("M399960 241 V94 h40 V428 h-40 V281 H0 v-40z"),
+  rightbracketunder: doubleBrushStroke("M399995 0 h-120 V290 H0 v120 H400000z"),
+  rightbracketover: doubleBrushStroke("M399995 440 h-120 V150 H0 v-120 H399995z"),
   rightToFrom: "M400000 167c-70.7-42-118-97.7-142-167h-23c-15.3 0-23 .3-23\n 1 0 1.3 5.3 13.7 16 37 18 35.3 41.3 69 70 101l7 8H0v40h399905l-7 8c-28.7 32\n-52 65.7-70 101-10.7 23.3-16 35.7-16 37 0 .7 7.7 1 23 1h23c24-69.3 71.3-125 142\n-167z M100 147v40h399900v-40zM0 341v40h399900v-40z",
   // twoheadleftarrow is from glyph U+219E in font KaTeX AMS Regular
   twoheadleftarrow: "M0 167c68 40\n 115.7 95.7 143 167h22c15.3 0 23-.3 23-1 0-1.3-5.3-13.7-16-37-18-35.3-41.3-69\n-70-101l-7-8h125l9 7c50.7 39.3 85 86 103 140h46c0-4.7-6.3-18.7-19-42-18-35.3\n-40-67.3-66-96l-9-9h399716v-40H284l9-9c26-28.7 48-60.7 66-96 12.7-23.333 19\n-37.333 19-42h-46c-18 54-52.3 100.7-103 140l-9 7H95l7-8c28.7-32 52-65.7 70-101\n 10.7-23.333 16-35.7 16-37 0-.7-7.7-1-23-1h-22C115.7 71.3 68 127 0 167z",
@@ -854,6 +899,10 @@ const tallDelim = function (label, midHeight) {
 ;// ./src/tree.ts
 // To ensure that all nodes have compatible signatures for these methods.
 
+function isMathDomNode(node) {
+  return 'toText' in node;
+}
+
 /**
  * This node represents a document fragment, which contains elements, but when
  * placed into the DOM doesn't have any representation itself. It only contains
@@ -863,6 +912,12 @@ class DocumentFragment {
   // Never used; needed for satisfying interface.
 
   constructor(children) {
+    this.children = void 0;
+    this.classes = void 0;
+    this.height = void 0;
+    this.depth = void 0;
+    this.maxFontSize = void 0;
+    this.style = void 0;
     this.children = children;
     this.classes = [];
     this.height = 0;
@@ -899,11 +954,12 @@ class DocumentFragment {
    * MathDomNode's only.
    */
   toText() {
-    // To avoid this, we would subclass documentFragment separately for
-    // MathML, but polyfills for subclassing is expensive per PR 1469.
-    // TODO(ts): Only works for ChildType = MathDomNode.
-    const toText = child => child.toText();
-    return this.children.map(toText).join("");
+    return this.children.map(child => {
+      if (isMathDomNode(child)) {
+        return child.toText();
+      }
+      throw new Error("Expected MathDomNode with toText, got " + child.constructor.name);
+    }).join("");
   }
 }
 ;// ./src/units.ts
@@ -1042,6 +1098,21 @@ const makeEm = function (n) {
 const createClass = function (classes) {
   return classes.filter(cls => cls).join(" ");
 };
+
+/**
+ * Serialize a CssStyle object into a semicolon-delimited inline-style string
+ * (hyphenating camelCase property names). Returns "" when no property is set.
+ */
+const cssStyleToString = function (style) {
+  let styles = "";
+  for (const key of Object.keys(style)) {
+    const value = style[key];
+    if (value !== undefined) {
+      styles += hyphenate(key) + ":" + value + ";";
+    }
+  }
+  return styles;
+};
 const initNode = function (classes, options, style) {
   this.classes = classes || [];
   this.attributes = {};
@@ -1070,9 +1141,7 @@ const toNode = function (tagName) {
   node.className = createClass(this.classes);
 
   // Apply inline styles
-  for (const key of Object.keys(this.style)) {
-    node.style[key] = this.style[key];
-  }
+  Object.assign(node.style, this.style);
 
   // Apply attributes
   for (const attr of Object.keys(this.attributes)) {
@@ -1106,12 +1175,7 @@ const toMarkup = function (tagName) {
   if (this.classes.length) {
     markup += " class=\"" + utils_escape(createClass(this.classes)) + "\"";
   }
-  let styles = "";
-
-  // Add the styles, after hyphenation
-  for (const key of Object.keys(this.style)) {
-    styles += hyphenate(key) + ":" + this.style[key] + ";";
-  }
+  const styles = cssStyleToString(this.style);
   if (styles) {
     markup += " style=\"" + utils_escape(styles) + "\"";
   }
@@ -1156,6 +1220,20 @@ const toMarkup = function (tagName) {
  */
 class Span {
   constructor(classes, children, options, style) {
+    this.children = void 0;
+    this.attributes = void 0;
+    this.classes = void 0;
+    this.height = void 0;
+    this.depth = void 0;
+    this.width = void 0;
+    this.maxFontSize = void 0;
+    this.style = void 0;
+    /**
+     * Italic correction carried over from a SymbolNode when the symbol is
+     * wrapped in a vlist (e.g. \oiint / \oiiint).  Read by supsub to adjust
+     * subscript positioning.  Only set when nonzero; use `?? 0` at read sites.
+     */
+    this.italic = void 0;
     initNode.call(this, classes, options, style);
     this.children = children || [];
   }
@@ -1185,6 +1263,13 @@ class Span {
  */
 class Anchor {
   constructor(href, classes, children, options) {
+    this.children = void 0;
+    this.attributes = void 0;
+    this.classes = void 0;
+    this.height = void 0;
+    this.depth = void 0;
+    this.maxFontSize = void 0;
+    this.style = void 0;
     initNode.call(this, classes, options);
     this.children = children || [];
     this.setAttribute('href', href);
@@ -1208,6 +1293,13 @@ class Anchor {
  */
 class Img {
   constructor(src, alt, style) {
+    this.src = void 0;
+    this.alt = void 0;
+    this.classes = void 0;
+    this.height = void 0;
+    this.depth = void 0;
+    this.maxFontSize = void 0;
+    this.style = void 0;
     this.alt = alt;
     this.src = src;
     this.classes = ["mord"];
@@ -1226,19 +1318,12 @@ class Img {
     node.className = "mord";
 
     // Apply inline styles
-    for (const key of Object.keys(this.style)) {
-      node.style[key] = this.style[key];
-    }
+    Object.assign(node.style, this.style);
     return node;
   }
   toMarkup() {
     let markup = "<img src=\"" + utils_escape(this.src) + "\"" + (" alt=\"" + utils_escape(this.alt) + "\"");
-
-    // Add the styles, after hyphenation
-    let styles = "";
-    for (const key of Object.keys(this.style)) {
-      styles += hyphenate(key) + ":" + this.style[key] + ";";
-    }
+    const styles = cssStyleToString(this.style);
     if (styles) {
       markup += " style=\"" + utils_escape(styles) + "\"";
     }
@@ -1261,6 +1346,15 @@ const iCombinations = {
  */
 class SymbolNode {
   constructor(text, height, depth, italic, skew, width, classes, style) {
+    this.text = void 0;
+    this.height = void 0;
+    this.depth = void 0;
+    this.italic = void 0;
+    this.skew = void 0;
+    this.width = void 0;
+    this.maxFontSize = void 0;
+    this.classes = void 0;
+    this.style = void 0;
     this.text = text;
     this.height = height || 0;
     this.depth = depth || 0;
@@ -1306,9 +1400,9 @@ class SymbolNode {
       span = span || document.createElement("span");
       span.className = createClass(this.classes);
     }
-    for (const key of Object.keys(this.style)) {
+    if (Object.keys(this.style).length > 0) {
       span = span || document.createElement("span");
-      span.style[key] = this.style[key];
+      Object.assign(span.style, this.style);
     }
     if (span) {
       span.appendChild(node);
@@ -1336,9 +1430,7 @@ class SymbolNode {
     if (this.italic > 0) {
       styles += "margin-right:" + makeEm(this.italic) + ";";
     }
-    for (const key of Object.keys(this.style)) {
-      styles += hyphenate(key) + ":" + this.style[key] + ";";
-    }
+    styles += cssStyleToString(this.style);
     if (styles) {
       needsSpan = true;
       markup += " style=\"" + utils_escape(styles) + "\"";
@@ -1360,6 +1452,8 @@ class SymbolNode {
  */
 class SvgNode {
   constructor(children, attributes) {
+    this.children = void 0;
+    this.attributes = void 0;
     this.children = children || [];
     this.attributes = attributes || {};
   }
@@ -1393,6 +1487,8 @@ class SvgNode {
 }
 class PathNode {
   constructor(pathName, alternate) {
+    this.pathName = void 0;
+    this.alternate = void 0;
     this.pathName = pathName;
     this.alternate = alternate; // Used only for \sqrt, \phase, & tall delims
   }
@@ -1416,6 +1512,7 @@ class PathNode {
 }
 class LineNode {
   constructor(attributes) {
+    this.attributes = void 0;
     this.attributes = attributes || {};
   }
   toNode() {
@@ -3539,6 +3636,12 @@ const hasHtmlDomChildren = node => node instanceof Span || node instanceof Ancho
 });
 ;// ./src/fontMetrics.ts
 
+// This map contains a mapping from font name and character code to character
+// metrics, including height, depth, italic correction, and skew (kern from the
+// character to the corresponding \skewchar)
+// This map is generated via `make metrics`. It should not be changed manually.
+
+
 /**
  * This file contains metrics regarding fonts and individual symbols. The sigma
  * and xi variables, as well as the metricMap map contain data extracted from
@@ -3653,12 +3756,6 @@ const sigmasAndXis = {
   fboxrule: [0.04, 0.04, 0.04] // 0.4 pt / ptPerEm
 };
 
-// This map contains a mapping from font name and character code to character
-// metrics, including height, depth, italic correction, and skew (kern from the
-// character to the corresponding \skewchar)
-// This map is generated via `make metrics`. It should not be changed manually.
-
-
 // These are very rough approximations.  We default to Times New Roman which
 // should have Latin-1 and Cyrillic characters, but may not depending on the
 // operating system.  The metrics do not account for extra height from the
@@ -3740,6 +3837,7 @@ const extraCharacterMap = {
   'ю': 'm',
   'я': 'r'
 };
+
 /**
  * This function adds new font metrics to default metricMap
  * It can also override existing metrics
@@ -3837,21 +3935,7 @@ function getGlobalMetrics(size) {
 // 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 symbols = {
   "math": {},
   "text": {}
@@ -4397,8 +4481,8 @@ defineSymbol(symbols_text, main, spacing, "\u00a0", "\\ ");
 defineSymbol(symbols_text, main, spacing, "\u00a0", " ");
 defineSymbol(symbols_text, main, spacing, "\u00a0", "\\space");
 defineSymbol(symbols_text, main, spacing, "\u00a0", "\\nobreakspace");
-defineSymbol(math, main, spacing, null, "\\nobreak");
-defineSymbol(math, main, spacing, null, "\\allowbreak");
+defineSymbol(math, main, spacing, "", "\\nobreak");
+defineSymbol(math, main, spacing, "", "\\allowbreak");
 defineSymbol(math, main, punct, ",", ",");
 defineSymbol(math, main, punct, ";", ";");
 defineSymbol(math, ams, bin, "\u22bc", "\\barwedge", true);
@@ -4600,7 +4684,7 @@ defineSymbol(symbols_text, main, mathord, "h", "\u210E");
 // 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.
-let wideChar = "";
+let wideChar;
 for (let i = 0; i < letters.length; i++) {
   const ch = letters.charAt(i);
 
@@ -4689,116 +4773,136 @@ for (let i = 0; i < extraLatin.length; i++) {
  */
 
 
+const boldUpright = {
+  mathClass: "mathbf",
+  textClass: "textbf",
+  font: "Main-Bold"
+};
+const italic = {
+  mathClass: "mathnormal",
+  textClass: "textit",
+  font: "Math-Italic"
+};
+const boldItalic = {
+  mathClass: "boldsymbol",
+  textClass: "boldsymbol",
+  font: "Main-BoldItalic"
+};
+const script = {
+  mathClass: "mathscr",
+  textClass: "textscr",
+  font: "Script-Regular"
+};
+const noFont = {
+  mathClass: "",
+  textClass: "",
+  font: ""
+};
+const fraktur = {
+  mathClass: "mathfrak",
+  textClass: "textfrak",
+  font: "Fraktur-Regular"
+};
+const doubleStruck = {
+  mathClass: "mathbb",
+  textClass: "textbb",
+  font: "AMS-Regular"
+};
+const boldFraktur = {
+  mathClass: "mathboldfrak",
+  textClass: "textboldfrak",
+  font: "Fraktur-Regular"
+};
+const sansSerif = {
+  mathClass: "mathsf",
+  textClass: "textsf",
+  font: "SansSerif-Regular"
+};
+const boldSansSerif = {
+  mathClass: "mathboldsf",
+  textClass: "textboldsf",
+  font: "SansSerif-Bold"
+};
+const italicSansSerif = {
+  mathClass: "mathitsf",
+  textClass: "textitsf",
+  font: "SansSerif-Italic"
+};
+const monospace = {
+  mathClass: "mathtt",
+  textClass: "texttt",
+  font: "Typewriter-Regular"
+};
 
 /**
  * Data below is from https://www.unicode.org/charts/PDF/U1D400.pdf
  * That document sorts characters into groups by font type, say bold or italic.
  *
- * In the arrays below, each subarray consists three elements:
+ * In the arrays below, each object consists of three properties:
  *      * The CSS class of that group when in math mode.
  *      * The CSS class of that group when in text mode.
  *      * The font name, so that KaTeX can get font metrics.
  */
 
-const wideLatinLetterData = [["mathbf", "textbf", "Main-Bold"],
-// A-Z bold upright
-["mathbf", "textbf", "Main-Bold"],
-// a-z bold upright
-
-["mathnormal", "textit", "Math-Italic"],
-// A-Z italic
-["mathnormal", "textit", "Math-Italic"],
-// a-z italic
-
-["boldsymbol", "boldsymbol", "Main-BoldItalic"],
-// A-Z bold italic
-["boldsymbol", "boldsymbol", "Main-BoldItalic"],
-// a-z bold italic
-
+const wideLatinLetterData = [boldUpright, boldUpright,
+// A-Z, a-z
+italic, italic,
+// A-Z, a-z
+boldItalic, boldItalic,
+// A-Z, a-z
 // Map fancy A-Z letters to script, not calligraphic.
 // This aligns with unicode-math and math fonts (except Cambria Math).
-["mathscr", "textscr", "Script-Regular"],
-// A-Z script
-["", "", ""],
-// a-z script.  No font
-
-["", "", ""],
-// A-Z bold script. No font
-["", "", ""],
-// a-z bold script. No font
-
-["mathfrak", "textfrak", "Fraktur-Regular"],
-// A-Z Fraktur
-["mathfrak", "textfrak", "Fraktur-Regular"],
-// a-z Fraktur
-
-["mathbb", "textbb", "AMS-Regular"],
-// A-Z double-struck
-["mathbb", "textbb", "AMS-Regular"],
-// k double-struck
-
+script, noFont,
+// A-Z script, a-z — no font
+noFont, noFont,
+// A-Z bold script, a-z bold script — no font
+fraktur, fraktur,
+// A-Z, a-z
+doubleStruck, doubleStruck,
+// A-Z double-struck, k double-struck
 // Note that we are using a bold font, but font metrics for regular Fraktur.
-["mathboldfrak", "textboldfrak", "Fraktur-Regular"],
-// A-Z bold Fraktur
-["mathboldfrak", "textboldfrak", "Fraktur-Regular"],
-// a-z bold Fraktur
-
-["mathsf", "textsf", "SansSerif-Regular"],
-// A-Z sans-serif
-["mathsf", "textsf", "SansSerif-Regular"],
-// a-z sans-serif
-
-["mathboldsf", "textboldsf", "SansSerif-Bold"],
-// A-Z bold sans-serif
-["mathboldsf", "textboldsf", "SansSerif-Bold"],
-// a-z bold sans-serif
-
-["mathitsf", "textitsf", "SansSerif-Italic"],
-// A-Z italic sans-serif
-["mathitsf", "textitsf", "SansSerif-Italic"],
-// a-z italic sans-serif
-
-["", "", ""],
-// A-Z bold italic sans. No font
-["", "", ""],
-// a-z bold italic sans. No font
-
-["mathtt", "texttt", "Typewriter-Regular"],
-// A-Z monospace
-["mathtt", "texttt", "Typewriter-Regular"] // a-z monospace
+boldFraktur, boldFraktur,
+// A-Z, a-z
+sansSerif, sansSerif,
+// A-Z, a-z
+boldSansSerif, boldSansSerif,
+// A-Z, a-z
+italicSansSerif, italicSansSerif,
+// A-Z, a-z
+noFont, noFont,
+// A-Z bold italic sans, a-z bold italic sans - no font
+monospace, monospace // A-Z, a-z
 ];
-const wideNumeralData = [["mathbf", "textbf", "Main-Bold"],
-// 0-9 bold
-["", "", ""],
+const wideNumeralData = [boldUpright,
+// 0-9
+noFont,
 // 0-9 double-struck. No KaTeX font.
-["mathsf", "textsf", "SansSerif-Regular"],
-// 0-9 sans-serif
-["mathboldsf", "textboldsf", "SansSerif-Bold"],
-// 0-9 bold sans-serif
-["mathtt", "texttt", "Typewriter-Regular"] // 0-9 monospace
+sansSerif,
+// 0-9
+boldSansSerif,
+// 0-9
+monospace // 0-9
 ];
-const wideCharacterFont = (wideChar, mode) => {
+const wideCharacterFont = wideChar => {
   // IE doesn't support codePointAt(). So work with the surrogate pair.
   const H = wideChar.charCodeAt(0); // high surrogate
   const L = wideChar.charCodeAt(1); // low surrogate
   const codePoint = (H - 0xD800) * 0x400 + (L - 0xDC00) + 0x10000;
-  const j = mode === "math" ? 0 : 1; // column index for CSS class.
-
   if (0x1D400 <= codePoint && codePoint < 0x1D6A4) {
     // wideLatinLetterData contains exactly 26 chars on each row.
     // So we can calculate the relevant row. No traverse necessary.
     const i = Math.floor((codePoint - 0x1D400) / 26);
-    return [wideLatinLetterData[i][2], wideLatinLetterData[i][j]];
+    return wideLatinLetterData[i];
   } else if (0x1D7CE <= codePoint && codePoint <= 0x1D7FF) {
     // Numerals, ten per row.
     const i = Math.floor((codePoint - 0x1D7CE) / 10);
-    return [wideNumeralData[i][2], wideNumeralData[i][j]];
+    return wideNumeralData[i];
   } else if (codePoint === 0x1D6A5 || codePoint === 0x1D6A6) {
     // dotless i or j
-    return [wideLatinLetterData[0][2], wideLatinLetterData[0][j]];
+    return wideLatinLetterData[0];
   } else if (0x1D6A6 < codePoint && codePoint < 0x1D7CE) {
     // Greek letters. Not supported, yet.
-    return ["", ""];
+    return noFont;
   } else {
     // We don't support any wide characters outside 1D400–1D7FF.
     throw new src_ParseError("Unsupported character: " + wideChar);
@@ -4821,9 +4925,7 @@ const wideCharacterFont = (wideChar, mode) => {
  * Looks up the given symbol in fontMetrics, after applying any symbol
  * replacements defined in symbol.js
  */
-const lookupSymbol = function (value,
-// TODO(#963): Use a union type for this.
-fontName, mode) {
+const lookupSymbol = function (value, fontName, mode) {
   // Replace the value with its replaced value from symbol.js
   if (src_symbols[mode][value]) {
     const replacement = src_symbols[mode][value].replace;
@@ -4906,7 +5008,7 @@ const mathsym = function (value, mode, options, classes) {
  * depending on the symbol.  Use this function instead of fontMap for font
  * "boldsymbol".
  */
-const boldsymbol = function (value, mode, options, classes, type) {
+const boldSymbol = function (value, mode, type) {
   if (type !== "textord" && lookupSymbol(value, "Math-BoldItalic", mode).metrics) {
     return {
       fontName: "Math-BoldItalic",
@@ -4929,31 +5031,39 @@ const makeOrd = function (group, options, type) {
   const mode = group.mode;
   const text = group.text;
   const classes = ["mord"];
+  const {
+    font,
+    fontFamily,
+    fontWeight,
+    fontShape
+  } = options;
 
   // Math mode or Old font (i.e. \rm)
-  const isFont = mode === "math" || mode === "text" && options.font;
-  const fontOrFamily = isFont ? options.font : options.fontFamily;
+  const useFont = mode === "math" || mode === "text" && !!font;
+  const fontOrFamily = useFont ? font : fontFamily;
   let wideFontName = "";
   let wideFontClass = "";
   if (text.charCodeAt(0) === 0xD835) {
-    [wideFontName, wideFontClass] = wideCharacterFont(text, mode);
+    const wideCharData = wideCharacterFont(text);
+    wideFontName = wideCharData.font;
+    wideFontClass = wideCharData[mode + "Class"];
   }
-  if (wideFontName.length > 0) {
+  if (wideFontName) {
     // surrogate pairs get special treatment
     return makeSymbol(text, wideFontName, mode, options, classes.concat(wideFontClass));
   } else if (fontOrFamily) {
     let fontName;
     let fontClasses;
     if (fontOrFamily === "boldsymbol") {
-      const fontData = boldsymbol(text, mode, options, classes, type);
+      const fontData = boldSymbol(text, mode, type);
       fontName = fontData.fontName;
       fontClasses = [fontData.fontClass];
-    } else if (isFont) {
-      fontName = fontMap[fontOrFamily].fontName;
-      fontClasses = [fontOrFamily];
+    } else if (useFont) {
+      fontName = fontMap[font].fontName;
+      fontClasses = [font];
     } else {
-      fontName = retrieveTextFontName(fontOrFamily, options.fontWeight, options.fontShape);
-      fontClasses = [fontOrFamily, options.fontWeight, options.fontShape];
+      fontName = retrieveTextFontName(fontFamily, fontWeight, fontShape);
+      fontClasses = [fontFamily, fontWeight, fontShape];
     }
     if (lookupSymbol(text, fontName, mode).metrics) {
       return makeSymbol(text, fontName, mode, options, classes.concat(fontClasses));
@@ -4973,16 +5083,16 @@ const makeOrd = function (group, options, type) {
   } else if (type === "textord") {
     const font = src_symbols[mode][text] && src_symbols[mode][text].font;
     if (font === "ams") {
-      const fontName = retrieveTextFontName("amsrm", options.fontWeight, options.fontShape);
-      return makeSymbol(text, fontName, mode, options, classes.concat("amsrm", options.fontWeight, options.fontShape));
+      const fontName = retrieveTextFontName("amsrm", fontWeight, fontShape);
+      return makeSymbol(text, fontName, mode, options, classes.concat("amsrm", fontWeight, fontShape));
     } else if (font === "main" || !font) {
-      const fontName = retrieveTextFontName("textrm", options.fontWeight, options.fontShape);
-      return makeSymbol(text, fontName, mode, options, classes.concat(options.fontWeight, options.fontShape));
+      const fontName = retrieveTextFontName("textrm", fontWeight, fontShape);
+      return makeSymbol(text, fontName, mode, options, classes.concat(fontWeight, fontShape));
     } else {
       // fonts added by plugins
-      const fontName = retrieveTextFontName(font, options.fontWeight, options.fontShape);
+      const fontName = retrieveTextFontName(font, fontWeight, fontShape);
       // We add font name as a css class
-      return makeSymbol(text, fontName, mode, options, classes.concat(fontName, options.fontWeight, options.fontShape));
+      return makeSymbol(text, fontName, mode, options, classes.concat(fontName, fontWeight, fontShape));
     }
   } else {
     throw new Error("unexpected type: " + type + " in makeOrd");
@@ -5290,8 +5400,9 @@ const makeGlue = (measurement, options) => {
 };
 
 // Takes font options, and returns the appropriate fontLookup name
-const retrieveTextFontName = function (fontFamily, fontWeight, fontShape) {
-  let baseFontName = "";
+const retrieveTextFontName = (fontFamily, fontWeight, fontShape) => {
+  let baseFontName;
+  let fontStylesName;
   switch (fontFamily) {
     case "amsrm":
       baseFontName = "AMS";
@@ -5309,12 +5420,11 @@ const retrieveTextFontName = function (fontFamily, fontWeight, fontShape) {
       baseFontName = fontFamily;
     // use fonts added by a plugin
   }
-  let fontStylesName;
   if (fontWeight === "textbf" && fontShape === "textit") {
     fontStylesName = "BoldItalic";
   } else if (fontWeight === "textbf") {
     fontStylesName = "Bold";
-  } else if (fontWeight === "textit") {
+  } else if (fontShape === "textit") {
     fontStylesName = "Italic";
   } else {
     fontStylesName = "Regular";
@@ -5537,13 +5647,20 @@ const _functions = {};
 /**
  * All HTML builders. Should be only used in the `define*` and the `build*ML`
  * functions.
+ *
+ * Builders for different node types are stored side by side, but
+ * `HtmlBuilder<T>` is contravariant in `T`, so there is no single type
+ * argument that makes storing/retrieving them typecheck.  `any` is used
+ * as an existential-quantifier escape hatch.
  */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 const _htmlGroupBuilders = {};
 
 /**
  * All MathML builders. Should be only used in the `define*` and the `build*ML`
- * functions.
+ * functions.  See `_htmlGroupBuilders` above for the rationale behind `any`.
  */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 const _mathmlGroupBuilders = {};
 function defineFunction(_ref) {
   let {
@@ -5749,7 +5866,8 @@ const traverseNonSpaceNodes = function (nodes, callback, prev, next, isRoot) {
     const partialGroup = checkPartialGroup(node);
     if (partialGroup) {
       // Recursive DFS
-      // TODO(ts): make nodes a $ReadOnlyArray by returning a new array
+      // TODO(ts): partialGroup.children is ReadonlyArray but this
+      // function mutates the array (insertAfter splices into it).
       traverseNonSpaceNodes(partialGroup.children, callback, prev, null, isRoot);
       continue;
     }
@@ -5837,8 +5955,8 @@ const buildGroup = function (group, options, baseOptions) {
     return makeSpan();
   }
   if (_htmlGroupBuilders[group.type]) {
-    // Call the groupBuilders function
-    // TODO(ts)
+    // TODO(ts): groupBuilders is Record<string, HtmlBuilder<any>>;
+    // a type-safe registry would need a mapped type keyed by NodeType.
     let groupNode = _htmlGroupBuilders[group.type](group, options);
 
     // If the size changed between the parent and the current group, account
@@ -5994,6 +6112,10 @@ function newDocumentFragment(children) {
  */
 class MathNode {
   constructor(type, children, classes) {
+    this.type = void 0;
+    this.attributes = void 0;
+    this.children = void 0;
+    this.classes = void 0;
     this.type = type;
     this.attributes = {};
     this.children = children || [];
@@ -6082,6 +6204,7 @@ class MathNode {
  */
 class TextNode {
   constructor(text) {
+    this.text = void 0;
     this.text = text;
   }
 
@@ -6118,6 +6241,8 @@ class SpaceNode {
    * Create a Space node with width given in CSS ems.
    */
   constructor(width) {
+    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 use Unicode
@@ -6217,57 +6342,55 @@ const makeRow = function (body) {
     return new MathNode("mrow", body);
   }
 };
+const mathFontVariants = {
+  mathit: "italic",
+  boldsymbol: group => group.type === "textord" ? "bold" : "bold-italic",
+  mathbf: "bold",
+  mathbb: "double-struck",
+  mathsfit: "sans-serif-italic",
+  mathfrak: "fraktur",
+  mathscr: "script",
+  mathcal: "script",
+  mathsf: "sans-serif",
+  mathtt: "monospace"
+};
 
 /**
  * Returns the math variant as a string or null if none is required.
  */
-const getVariant = function (group, options) {
+const getVariant = (group, options) => {
   // Handle \text... font specifiers as best we can.
   // MathML has a limited list of allowable mathvariant specifiers; see
   // https://www.w3.org/TR/MathML3/chapter3.html#presm.commatt
-  if (options.fontFamily === "texttt") {
-    return "monospace";
-  } else if (options.fontFamily === "textsf") {
-    if (options.fontShape === "textit" && options.fontWeight === "textbf") {
-      return "sans-serif-bold-italic";
+  if (group.mode === "text") {
+    if (options.fontFamily === "texttt") {
+      return "monospace";
+    } else if (options.fontFamily === "textsf") {
+      if (options.fontShape === "textit" && options.fontWeight === "textbf") {
+        return "sans-serif-bold-italic";
+      } else if (options.fontShape === "textit") {
+        return "sans-serif-italic";
+      } else if (options.fontWeight === "textbf") {
+        return "bold-sans-serif";
+      } else {
+        return "sans-serif";
+      }
+    } else if (options.fontShape === "textit" && options.fontWeight === "textbf") {
+      return "bold-italic";
     } else if (options.fontShape === "textit") {
-      return "sans-serif-italic";
+      return "italic";
     } else if (options.fontWeight === "textbf") {
-      return "bold-sans-serif";
-    } else {
-      return "sans-serif";
+      return "bold";
     }
-  } else if (options.fontShape === "textit" && options.fontWeight === "textbf") {
-    return "bold-italic";
-  } else if (options.fontShape === "textit") {
-    return "italic";
-  } else if (options.fontWeight === "textbf") {
-    return "bold";
   }
   const font = options.font;
   if (!font || font === "mathnormal") {
     return null;
   }
   const mode = group.mode;
-  if (font === "mathit") {
-    return "italic";
-  } else if (font === "boldsymbol") {
-    return group.type === "textord" ? "bold" : "bold-italic";
-  } else if (font === "mathbf") {
-    return "bold";
-  } else if (font === "mathbb") {
-    return "double-struck";
-  } else if (font === "mathsfit") {
-    return "sans-serif-italic";
-  } else if (font === "mathfrak") {
-    return "fraktur";
-  } else if (font === "mathscr" || font === "mathcal") {
-    // MathML makes no distinction between script and calligraphic
-    return "script";
-  } else if (font === "mathsf") {
-    return "sans-serif";
-  } else if (font === "mathtt") {
-    return "monospace";
+  const mathVariant = mathFontVariants[font];
+  if (mathVariant) {
+    return typeof mathVariant === "function" ? mathVariant(group) : mathVariant;
   }
   let text = group.text;
   if (noVariantSymbols.has(text)) {
@@ -6387,11 +6510,10 @@ const buildMathML_buildGroup = function (group, options) {
     return new MathNode("mrow");
   }
   if (_mathmlGroupBuilders[group.type]) {
-    // Call the groupBuilders function
-    // TODO(ts)
-    const result = _mathmlGroupBuilders[group.type](group, options);
-    // TODO(ts)
-    return result;
+    // TODO(ts): MathMLBuilder returns MathDomNode but all concrete
+    // builders return MathNode. Widening the return type here would
+    // require updating all callers that assume MathNode.
+    return _mathmlGroupBuilders[group.type](group, options);
   } else {
     throw new src_ParseError("Got group of unknown type: '" + group.type + "'");
   }
@@ -6436,8 +6558,11 @@ function buildMathML(tree, texExpression, options, isDisplayMode, forMathmlOnly)
   // NOTE: The span class is not typed to have <math> nodes as children, and
   // we don't want to make the children type more generic since the children
   // of span are expected to have more fields in `buildHtml` contexts.
+  // The MathNode implements VirtualNode (toNode/toMarkup) which is all that
+  // Span needs from its children for rendering.
+  // TODO(ts): Span's child type is HtmlDomNode, but MathNode only implements
+  // VirtualNode. The double-cast acknowledges this architectural limitation.
   const wrapperClass = forMathmlOnly ? "katex" : "katex-mathml";
-  // TODO(ts)
   return makeSpan([wrapperClass], [math]);
 }
 ;// ./src/Options.ts
@@ -6481,9 +6606,6 @@ const sizeMultipliers = [
 const sizeAtStyle = function (size, style) {
   return style.size < 2 ? size : sizeStyleMap[size - 1][style.size - 1];
 };
-
-// In these types, "" (empty string) means "no change".
-
 /**
  * This is the main options class. It contains the current style, size, color,
  * and font.
@@ -6493,6 +6615,22 @@ const sizeAtStyle = function (size, style) {
  */
 class Options {
   constructor(data) {
+    this.style = void 0;
+    this.color = void 0;
+    this.size = void 0;
+    this.textSize = void 0;
+    this.phantom = void 0;
+    // A font family applies to a group of fonts (i.e. SansSerif), while a font
+    // represents a specific font (i.e. SansSerif Bold).
+    // See: https://tex.stackexchange.com/questions/22350/difference-between-textrm-and-mathrm
+    this.font = void 0;
+    this.fontFamily = void 0;
+    this.fontWeight = void 0;
+    this.fontShape = void 0;
+    this.sizeMultiplier = void 0;
+    this.maxSize = void 0;
+    this.minRuleThickness = void 0;
+    this._fontMetrics = void 0;
     this.style = data.style;
     this.color = data.color;
     this.size = data.size || Options.BASESIZE;
@@ -6500,8 +6638,8 @@ class Options {
     this.phantom = !!data.phantom;
     this.font = data.font || "";
     this.fontFamily = data.fontFamily || "";
-    this.fontWeight = data.fontWeight || '';
-    this.fontShape = data.fontShape || '';
+    this.fontWeight = data.fontWeight || "";
+    this.fontShape = data.fontShape || "";
     this.sizeMultiplier = sizeMultipliers[this.size - 1];
     this.maxSize = data.maxSize;
     this.minRuleThickness = data.minRuleThickness;
@@ -6715,9 +6853,6 @@ class Options {
     }
   }
 }
-// A font family applies to a group of fonts (i.e. SansSerif), while a font
-// represents a specific font (i.e. SansSerif Bold).
-// See: https://tex.stackexchange.com/questions/22350/difference-between-textrm-and-mathrm
 /**
  * The base size index.
  */
@@ -6863,18 +6998,6 @@ const stretchyMathML = function (label) {
 //    Some functions, such as \cancel, need to vary their aspect ratio. These
 //    functions do not get the overflow SVG treatment.
 
-// Second Brush Stroke
-//    Low resolution monitors struggle to display images in fine detail.
-//    So browsers apply anti-aliasing. A long straight arrow shaft therefore
-//    will sometimes appear as if it has a blurred edge.
-
-//    To mitigate this, these SVG files contain a second "brush-stroke" on the
-//    arrow shafts. That is, a second long thin rectangular SVG path has been
-//    written directly on top of each arrow shaft. This reinforcement causes
-//    some of the screen pixels to display as black instead of the anti-aliased
-//    gray pixel that a  single path would generate. So we get arrow shafts
-//    whose edges appear to be sharper.
-
 // In the katexImagesData object just below, the dimensions all
 // correspond to path geometry inside the relevant SVG.
 // For example, \overrightarrow uses the same arrowhead as glyph U+2192
@@ -6938,14 +7061,10 @@ const stretchySvg = function (group, options) {
   function buildSvgSpan_() {
     let viewBoxWidth = 400000; // default
     const label = group.label.slice(1);
-    if (wideAccentLabels.has(label)) {
-      // Each type in the `if` statement corresponds to one of the ParseNode
-      // types below. This narrowing is required to access `grp.base`.
-      // TODO(ts)
-      const grp = group;
+    if (wideAccentLabels.has(label) && 'base' in group) {
       // There are four SVG images available for each function.
       // Choose a taller image when there are more characters.
-      const numChars = grp.base.type === "ordgroup" ? grp.base.body.length : 1;
+      const numChars = group.base.type === "ordgroup" ? group.base.body.length : 1;
       let viewBoxHeight;
       let pathName;
       let height;
@@ -6990,16 +7109,20 @@ const stretchySvg = function (group, options) {
     } else {
       const spans = [];
       const data = katexImagesData[label];
+      if (!data) {
+        throw new Error("No SVG data for \"" + label + "\".");
+      }
       const [paths, minWidth, viewBoxHeight] = data;
       const height = viewBoxHeight / 1000;
       const numSvgChildren = paths.length;
       let widthClasses;
       let aligns;
       if (numSvgChildren === 1) {
-        // TODO(ts): All these cases must be of the 4-tuple type.
-        const align1 = data[3];
+        if (data.length !== 4) {
+          throw new Error("Expected 4-tuple for single-path SVG data \"" + label + "\".");
+        }
         widthClasses = ["hide-tail"];
-        aligns = [align1];
+        aligns = [data[3]];
       } else if (numSvgChildren === 2) {
         widthClasses = ["halfarrow-left", "halfarrow-right"];
         aligns = ["xMinYMin", "xMaxYMin"];
@@ -7097,6 +7220,35 @@ const stretchyEnclose = function (inner, label, topPad, bottomPad, options) {
   img.style.height = makeEm(totalHeight);
   return img;
 };
+;// ./src/atoms.ts
+/**
+ * Small module for atom-group constants and type guard.  Kept separate from
+ * `symbols.ts` so that consumers (notably `contrib/render-a11y-string`) can
+ * 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
+};
+function isAtom(value) {
+  return value in ATOMS;
+}
 ;// ./src/parseNode.ts
 
 
@@ -7526,7 +7678,8 @@ defineFunction({
         }, {
           type: "elem",
           elem: arrowBody,
-          shift: arrowShift
+          shift: arrowShift,
+          wrapperClasses: ["svg-align"]
         }, {
           type: "elem",
           elem: lowerGroup,
@@ -7543,13 +7696,11 @@ defineFunction({
         }, {
           type: "elem",
           elem: arrowBody,
-          shift: arrowShift
+          shift: arrowShift,
+          wrapperClasses: ["svg-align"]
         }]
       }, options);
     }
-
-    // TODO(ts): Replace this with passing "svg-align" into makeVList.
-    vlist.children[0].children[0].children[1].classes.push("svg-align");
     return makeSpan(["mrel", "x-arrow"], [vlist], options);
   },
   mathmlBuilder(group, options) {
@@ -7809,7 +7960,8 @@ const newCell = () => {
     type: "styling",
     body: [],
     mode: "math",
-    style: "display"
+    style: "display",
+    resetFont: true
   };
 };
 const isStartOfArrow = node => {
@@ -7871,7 +8023,6 @@ function parseCD(parser) {
   parser.gullet.macros.set("\\cr", "\\\\\\relax");
   parser.gullet.beginGroup();
   while (true) {
-    // eslint-disable-line no-constant-condition
     // Get the parse nodes for the next row.
     parsedRows.push(parser.parseExpression(false, "\\\\"));
     parser.gullet.endGroup();
@@ -7964,7 +8115,9 @@ function parseCD(parser) {
           type: "styling",
           body: [arrow],
           mode: "math",
-          style: "display" // CD is always displaystyle.
+          style: "display",
+          // CD is always displaystyle.
+          resetFont: true
         };
         row.push(wrappedArrow);
         // In CD's syntax, cells are implicit. That is, everything that
@@ -8909,9 +9062,9 @@ const makeSqrtImage = function (height, options) {
 
   // Create a span containing an SVG image of a sqrt symbol.
   let span;
-  let spanHeight = 0;
-  let texHeight = 0;
-  let viewBoxHeight = 0;
+  let spanHeight;
+  let texHeight;
+  let viewBoxHeight;
   let advanceWidth;
 
   // We create viewBoxes with 80 units of "padding" above each surd.
@@ -9273,6 +9426,16 @@ const delimiterSizes = {
   }
 };
 const delimiters = new Set(["(", "\\lparen", ")", "\\rparen", "[", "\\lbrack", "]", "\\rbrack", "\\{", "\\lbrace", "\\}", "\\rbrace", "\\lfloor", "\\rfloor", "\u230a", "\u230b", "\\lceil", "\\rceil", "\u2308", "\u2309", "<", ">", "\\langle", "\u27e8", "\\rangle", "\u27e9", "\\lt", "\\gt", "\\lvert", "\\rvert", "\\lVert", "\\rVert", "\\lgroup", "\\rgroup", "\u27ee", "\u27ef", "\\lmoustache", "\\rmoustache", "\u23b0", "\u23b1", "/", "\\backslash", "|", "\\vert", "\\|", "\\Vert", "\\uparrow", "\\Uparrow", "\\downarrow", "\\Downarrow", "\\updownarrow", "\\Updownarrow", "."]);
+
+/**
+ * An HtmlDomNode that carries an `isMiddle` property, used by the
+ * \middle command to communicate delimiter info to the \left/\right builder.
+ */
+
+function isMiddleDelimNode(node) {
+  return 'isMiddle' in node;
+}
+
 // Delimiter functions
 function checkDelimiter(delim, context) {
   const symDelim = checkSymbolNodeType(delim);
@@ -9396,10 +9559,8 @@ defineFunction({
 
     // Calculate its height and depth
     for (let i = 0; i < inner.length; i++) {
-      // Property `isMiddle` not defined on `span`. See comment in
-      // "middle"'s htmlBuilder.
-      // TODO(ts)
-      if (inner[i].isMiddle) {
+      const node = inner[i];
+      if (isMiddleDelimNode(node)) {
         hadMiddle = true;
       } else {
         innerHeight = Math.max(inner[i].height, innerHeight);
@@ -9428,11 +9589,8 @@ defineFunction({
     if (hadMiddle) {
       for (let i = 1; i < inner.length; i++) {
         const middleDelim = inner[i];
-        // Property `isMiddle` not defined on `span`. See comment in
-        // "middle"'s htmlBuilder.
-        // TODO(ts)
-        const isMiddle = middleDelim.isMiddle;
-        if (isMiddle) {
+        if (isMiddleDelimNode(middleDelim)) {
+          const isMiddle = middleDelim.isMiddle;
           // Apply the options that were active when \middle was called
           inner[i] = makeLeftRightDelim(isMiddle.delim, innerHeight, innerDepth, isMiddle.options, group.mode, []);
         }
@@ -9493,16 +9651,15 @@ defineFunction({
       middleDelim = makeNullDelimiter(options, []);
     } else {
       middleDelim = makeSizedDelim(group.delim, 1, options, group.mode, []);
-      const isMiddle = {
+
+      // Patch an ad-hoc property onto the node so the \left/\right
+      // builder can reconstruct appropriately sized middle delimiters.
+      // isMiddle is not part of HtmlDomNode; the read side uses
+      // isMiddleDelimNode() to check before accessing.
+      middleDelim.isMiddle = {
         delim: group.delim,
         options
       };
-      // Property `isMiddle` not defined on `span`. It is only used in
-      // this file above.
-      // TODO: Fix this violation of the `span` type and possibly rename
-      // things since `isMiddle` sounds like a boolean, but is a struct.
-      // TODO(ts)
-      middleDelim.isMiddle = isMiddle;
     }
     return middleDelim;
   },
@@ -9541,7 +9698,7 @@ const enclose_htmlBuilder = (group, options) => {
   const label = group.label.slice(1);
   let scale = options.sizeMultiplier;
   let img;
-  let imgShift = 0;
+  let imgShift;
 
   // In the LaTeX cancel package, line geometry is slightly different
   // depending on whether the subject is wider than it is tall, or vice versa.
@@ -9597,8 +9754,8 @@ const enclose_htmlBuilder = (group, options) => {
     }
 
     // Add vertical padding
-    let topPad = 0;
-    let bottomPad = 0;
+    let topPad;
+    let bottomPad;
     let ruleThickness = 0;
     // ref: cancel package: \advance\totalheight2\p@ % "+2"
     if (/box/.test(label)) {
@@ -9680,7 +9837,7 @@ const enclose_htmlBuilder = (group, options) => {
   }
 };
 const enclose_mathmlBuilder = (group, options) => {
-  let fboxsep = 0;
+  let fboxsep;
   const node = new MathNode(group.label.includes("colorbox") ? "mpadded" : "menclose", [buildMathML_buildGroup(group.body, options)]);
   switch (group.label) {
     case "\\cancel":
@@ -9733,7 +9890,7 @@ defineFunction({
   props: {
     numArgs: 2,
     allowedInText: true,
-    argTypes: ["color", "text"]
+    argTypes: ["color", "hbox"]
   },
   handler(_ref, args, optArgs) {
     let {
@@ -9759,7 +9916,7 @@ defineFunction({
   props: {
     numArgs: 3,
     allowedInText: true,
-    argTypes: ["color", "color", "text"]
+    argTypes: ["color", "color", "hbox"]
   },
   handler(_ref2, args, optArgs) {
     let {
@@ -9962,12 +10119,15 @@ function defineMacro(name, body) {
  * This object is immutable.
  */
 class SourceLocation {
-  // The + prefix indicates that these fields aren't writeable
-  // Lexer holding the input string.
-  // Start offset, zero-based inclusive.
   // End offset, zero-based exclusive.
 
   constructor(lexer, start, end) {
+    // The + prefix indicates that these fields aren't writeable
+    this.lexer = void 0;
+    // Lexer holding the input string.
+    this.start = void 0;
+    // Start offset, zero-based inclusive.
+    this.end = void 0;
     this.lexer = lexer;
     this.start = start;
     this.end = end;
@@ -10013,12 +10173,16 @@ class SourceLocation {
  * lead to degraded error reporting, though.
  */
 class Token {
-  // don't expand the token
   // used in \noexpand
 
   constructor(text,
   // the text of this token
   loc) {
+    this.text = void 0;
+    this.loc = void 0;
+    this.noexpand = void 0;
+    // don't expand the token
+    this.treatAsRelax = void 0;
     this.text = text;
     this.loc = loc;
   }
@@ -10166,7 +10330,6 @@ function parseArray(parser, _ref, style) {
   // Test for \hline at the top of the array.
   hLinesBeforeRow.push(getHLines(parser));
   while (true) {
-    // eslint-disable-line no-constant-condition
     // Parse each cell in its own group (namespace)
     const cellBody = parser.parseExpression(false, singleRow ? "\\end" : "\\\\");
     parser.gullet.endGroup();
@@ -10181,6 +10344,7 @@ function parseArray(parser, _ref, style) {
         type: "styling",
         mode: parser.mode,
         style,
+        resetFont: true,
         body: [cell]
       };
     }
@@ -10324,7 +10488,12 @@ const array_htmlBuilder = function (group, options) {
     if (nc < inrow.length) {
       nc = inrow.length;
     }
-    const outrow = new Array(inrow.length);
+    const outrow = {
+      cells: new Array(inrow.length),
+      height: 0,
+      depth: 0,
+      pos: 0
+    };
     for (c = 0; c < inrow.length; ++c) {
       const elt = buildGroup(inrow[c], options);
       if (depth < elt.depth) {
@@ -10333,7 +10502,7 @@ const array_htmlBuilder = function (group, options) {
       if (height < elt.height) {
         height = elt.height;
       }
-      outrow[c] = elt;
+      outrow.cells[c] = elt;
     }
     const rowGap = group.rowGaps[r];
     let gap = 0;
@@ -10449,7 +10618,7 @@ const array_htmlBuilder = function (group, options) {
     const colElems = [];
     for (r = 0; r < nr; ++r) {
       const row = body[r];
-      const elem = row[c];
+      const elem = row.cells[c];
       if (!elem) {
         continue;
       }
@@ -11081,7 +11250,6 @@ const environments = _environments;
 
 
 
-
 // Environment delimiters. HTML/MathML rendering is defined in the corresponding
 // defineEnvironment definitions.
 defineFunction({
@@ -11128,7 +11296,10 @@ defineFunction({
       if (end.name !== envName) {
         throw new src_ParseError("Mismatch: \\begin{" + envName + "} matched by \\end{" + end.name + "}", endNameToken);
       }
-      // TODO(ts), "environment" handler returns an environment ParseNode
+      // env.handler returns the specific node type (e.g. "array"),
+      // not "environment". This cast is unavoidable: defineFunction
+      // requires the handler to return ParseNode<"environment"> but
+      // \begin delegates to environment handlers with different types.
       return result;
     }
     return {
@@ -11160,8 +11331,7 @@ const font_mathmlBuilder = (group, options) => {
 const fontAliases = {
   "\\Bbb": "\\mathbb",
   "\\bold": "\\mathbf",
-  "\\frak": "\\mathfrak",
-  "\\bm": "\\boldsymbol"
+  "\\frak": "\\mathfrak"
 };
 defineFunction({
   type: "font",
@@ -11242,11 +11412,10 @@ defineFunction({
       mode
     } = parser;
     const body = parser.parseExpression(true, breakOnTokenText);
-    const style = "math" + funcName.slice(1);
     return {
       type: "font",
       mode: mode,
-      font: style,
+      font: "math" + funcName.slice(1),
       body: {
         type: "ordgroup",
         mode: parser.mode,
@@ -11730,18 +11899,18 @@ const horizBrace_htmlBuilder = (grp, options) => {
         size: 0.1
       }, {
         type: "elem",
-        elem: braceBody
+        elem: braceBody,
+        wrapperClasses: ["svg-align"]
       }]
     }, options);
-    // TODO(ts): Replace this with passing "svg-align" into makeVList.
-    vlist.children[0].children[0].children[1].classes.push("svg-align");
   } else {
     vlist = makeVList({
       positionType: "bottom",
       positionData: body.depth + 0.1 + braceBody.height,
       children: [{
         type: "elem",
-        elem: braceBody
+        elem: braceBody,
+        wrapperClasses: ["svg-align"]
       }, {
         type: "kern",
         size: 0.1
@@ -11750,8 +11919,6 @@ const horizBrace_htmlBuilder = (grp, options) => {
         elem: body
       }]
     }, options);
-    // TODO(ts): Replace this with passing "svg-align" into makeVList.
-    vlist.children[0].children[0].children[0].classes.push("svg-align");
   }
   if (supSubGroup) {
     // To write the supsub, wrap the first vlist in another vlist:
@@ -11949,11 +12116,11 @@ defineFunction({
     };
   },
   htmlBuilder(group, options) {
-    const elements = buildExpression(group.body, options, false);
+    const elements = buildExpression(group.body, options.withFont(''), false);
     return makeFragment(elements);
   },
   mathmlBuilder(group, options) {
-    return new MathNode("mrow", buildMathML_buildExpression(group.body, options));
+    return new MathNode("mrow", buildMathML_buildExpression(group.body, options.withFont('')));
   }
 });
 ;// ./src/functions/html.ts
@@ -12393,6 +12560,7 @@ defineFunction({
       type: "styling",
       mode: parser.mode,
       style: "text",
+      resetFont: true,
       body
     };
   }
@@ -12627,6 +12795,9 @@ const op_htmlBuilder = (grp, options) => {
     large = true;
   }
   let base;
+  // Italic correction from the symbol glyph, captured before the symbol
+  // may be wrapped in a vlist (for \oiint/\oiiint).  Stays 0 for non-symbol ops.
+  let symbolItalic;
   if (group.symbol) {
     // If this is a symbol, create the symbol.
     const fontName = large ? "Size2-Regular" : "Size1-Regular";
@@ -12638,10 +12809,10 @@ const op_htmlBuilder = (grp, options) => {
       group.name = stash === "oiint" ? "\\iint" : "\\iiint";
     }
     base = makeSymbol(group.name, fontName, "math", options, ["mop", "op-symbol", large ? "large-op" : "small-op"]);
+    symbolItalic = base.italic;
     if (stash.length > 0) {
       // We're in \oiint or \oiiint. Overlay the oval.
       // TODO: When font glyphs are available, delete this code.
-      const italic = base.italic;
       const oval = staticSvg(stash + "Size" + (large ? "2" : "1"), options);
       base = makeVList({
         positionType: "individualShift",
@@ -12657,8 +12828,9 @@ const op_htmlBuilder = (grp, options) => {
       }, options);
       group.name = "\\" + stash;
       base.classes.unshift("mop");
-      // TODO(ts)
-      base.italic = italic;
+      // Carry the italic correction from the original symbol to the
+      // vlist wrapper so supsub can use it for subscript positioning.
+      base.italic = symbolItalic;
     }
   } else if (group.body) {
     // If this is a list, compose that list.
@@ -12683,6 +12855,7 @@ const op_htmlBuilder = (grp, options) => {
   let baseShift = 0;
   let slant = 0;
   if ((base instanceof SymbolNode || group.name === "\\oiint" || group.name === "\\oiiint") && !group.suppressBaseShift) {
+    var _base$italic;
     // We suppress the shift of the base of \overset and \underset. Otherwise,
     // shift the symbol so its center lies on the axis (rule 13). It
     // appears that our fonts have the centers of the symbols already
@@ -12692,8 +12865,9 @@ const op_htmlBuilder = (grp, options) => {
     baseShift = (base.height - base.depth) / 2 - options.fontMetrics().axisHeight;
 
     // The slant of the symbol is just its italic correction.
-    // TODO(ts)
-    slant = base.italic || 0;
+    // SymbolNode carries .italic natively; Span (for \oiint/\oiiint)
+    // only has it set when nonzero, so default to 0.
+    slant = (_base$italic = base.italic) != null ? _base$italic : 0;
   }
   if (hasLimits) {
     return assembleSupSub(base, supGroup, subGroup, options, style, slant, baseShift);
@@ -13427,7 +13601,7 @@ defineFunction({
       // Optional [tb] argument is engaged.
       // ref: amsmath: \renewcommand{\smash}[1][tb]{%
       //               def\mb@t{\ht}\def\mb@b{\dp}\def\mb@tb{\ht\z@\z@\dp}%
-      let letter = "";
+      let letter;
       for (let i = 0; i < tbArg.body.length; ++i) {
         const node = tbArg.body[i];
         letter = assertSymbolNodeType(node).text;
@@ -13649,6 +13823,9 @@ const styling_styleMap = {
   "script": src_Style.SCRIPT,
   "scriptscript": src_Style.SCRIPTSCRIPT
 };
+function isStyleStr(s) {
+  return s in styling_styleMap;
+}
 defineFunction({
   type: "styling",
   names: ["\\displaystyle", "\\textstyle", "\\scriptstyle", "\\scriptscriptstyle"],
@@ -13668,8 +13845,10 @@ defineFunction({
 
     // TODO: Refactor to avoid duplicating styleMap in multiple places (e.g.
     // here and in buildHTML and de-dupe the enumeration of all the styles).
-    // TODO(ts): The names above exactly match the styles.
     const style = funcName.slice(1, funcName.length - 5);
+    if (!isStyleStr(style)) {
+      throw new Error("Unknown style: " + style);
+    }
     return {
       type: "styling",
       mode: parser.mode,
@@ -13682,13 +13861,19 @@ defineFunction({
   htmlBuilder(group, options) {
     // Style changes are handled in the TeXbook on pg. 442, Rule 3.
     const newStyle = styling_styleMap[group.style];
-    const newOptions = options.havingStyle(newStyle).withFont('');
+    let newOptions = options.havingStyle(newStyle);
+    if (group.resetFont) {
+      newOptions = newOptions.withFont('');
+    }
     return sizingGroup(group.body, newOptions, options);
   },
   mathmlBuilder(group, options) {
     // Figure out what style we're changing to.
     const newStyle = styling_styleMap[group.style];
-    const newOptions = options.havingStyle(newStyle);
+    let newOptions = options.havingStyle(newStyle);
+    if (group.resetFont) {
+      newOptions = newOptions.withFont('');
+    }
     const inner = buildMathML_buildExpression(group.body, newOptions);
     const node = new MathNode("mstyle", inner);
     const styleAttributes = {
@@ -13724,7 +13909,9 @@ defineFunction({
  * its inner element should handle the superscripts and subscripts instead of
  * handling them itself.
  */
-const htmlBuilderDelegate = function (group, options) {
+const htmlBuilderDelegate = function (group, options
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+) {
   const base = group.base;
   if (!base) {
     return null;
@@ -13810,8 +13997,10 @@ defineFunctionBuilders({
       // amount. Note we only do this when the base is a single symbol.
       const isOiint = group.base && group.base.type === "op" && group.base.name && (group.base.name === "\\oiint" || group.base.name === "\\oiiint");
       if (base instanceof SymbolNode || isOiint) {
-        // @ts-ignore
-        marginLeft = makeEm(-base.italic);
+        var _italic;
+        // SymbolNode has .italic natively; for \oiint/\oiiint the
+        // op builder stores .italic on the wrapping Span.
+        marginLeft = makeEm(-((_italic = base.italic) != null ? _italic : 0));
       }
     }
     let supsub;
@@ -14286,7 +14475,9 @@ defineFunction({
     // There is no way to do this in MathML.
     // Write a class as a breadcrumb in case some post-processor wants
     // to perform a vcenter adjustment.
-    return new MathNode("mpadded", [buildMathML_buildGroup(group.body, options)], ["vcenter"]);
+    // Wrap in mrow to ensure valid MathML when placed inside mo (e.g., \mathrel)
+    const mpadded = new MathNode("mpadded", [buildMathML_buildGroup(group.body, options)], ["vcenter"]);
+    return new MathNode("mrow", [mpadded]);
   }
 });
 ;// ./src/functions/verb.ts
@@ -14455,10 +14646,13 @@ combiningDiacriticalMarkString + "*") +
 
 /** Main Lexer class */
 class Lexer {
-  // Category codes. The lexer only supports comment characters (14) for now.
-  // MacroExpander additionally distinguishes active (13).
-
   constructor(input, settings) {
+    this.input = void 0;
+    this.settings = void 0;
+    this.tokenRegex = void 0;
+    // Category codes. The lexer only supports comment characters (14) for now.
+    // MacroExpander additionally distinguishes active (13).
+    this.catcodes = void 0;
     // Separate accents from characters
     this.input = input;
     this.settings = settings;
@@ -14525,6 +14719,9 @@ class Namespace {
     if (globalMacros === void 0) {
       globalMacros = {};
     }
+    this.current = void 0;
+    this.builtins = void 0;
+    this.undefStack = void 0;
     this.current = globalMacros;
     this.builtins = builtins;
     this.undefStack = [];
@@ -15628,6 +15825,12 @@ const implicitCommands = {
 };
 class MacroExpander {
   constructor(input, settings, mode) {
+    this.settings = void 0;
+    this.expansionCount = void 0;
+    this.lexer = void 0;
+    this.macros = void 0;
+    this.stack = void 0;
+    this.mode = void 0;
     this.settings = settings;
     this.expansionCount = 0;
     this.feed(input);
@@ -16174,6 +16377,7 @@ const uSubsAndSups = Object.freeze({
 
 
 
+
 // Pre-evaluate both modules as unicodeSymbols require String.normalize()
 const unicodeAccents = {
   "́": {
@@ -16601,6 +16805,11 @@ const unicodeSymbols = {
 
 class Parser {
   constructor(input, settings) {
+    this.mode = void 0;
+    this.gullet = void 0;
+    this.settings = void 0;
+    this.leftrightDepth = void 0;
+    this.nextToken = void 0;
     // Start in math mode
     this.mode = "math";
     // Create a new macro expander (gullet) and (indirectly via that) also a
@@ -17105,13 +17314,16 @@ class Parser {
       case "hbox":
         {
           // hbox argument type wraps the argument in the equivalent of
-          // \hbox, which is like \text but switching to \textstyle size.
+          // \hbox, which is like \text but switching to \textstyle size
+          // and resetting math font.
           const group = this.parseArgumentGroup(optional, "text");
           return group != null ? {
             type: "styling",
             mode: group.mode,
             body: [group],
-            style: "text" // simulate \textstyle
+            style: "text",
+            // simulate \textstyle
+            resetFont: true
           } : null;
         }
       case "raw":
@@ -17477,18 +17689,15 @@ class Parser {
       const group = src_symbols[this.mode][text].group;
       const loc = SourceLocation.range(nucleus);
       let s;
-      if (ATOMS.hasOwnProperty(group)) {
-        // TODO(ts)
-        const family = group;
+      if (isAtom(group)) {
         s = {
           type: "atom",
           mode: this.mode,
-          family,
+          family: group,
           loc,
           text
         };
       } else {
-        // TODO(ts)
         s = {
           type: group,
           mode: this.mode,
@@ -17496,7 +17705,6 @@ class Parser {
           text
         };
       }
-      // TODO(ts)
       symbol = s;
     } else if (text.charCodeAt(0) >= 0x80) {
       // no symbol for e.g. ^
@@ -17542,12 +17750,10 @@ class Parser {
           label: command,
           isStretchy: false,
           isShifty: true,
-          // TODO(ts)
           base: symbol
         };
       }
     }
-    // TODO(ts)
     return symbol;
   }
 }
@@ -17693,7 +17899,7 @@ const renderToHTMLTree = function (expression, options) {
     return renderError(error, expression, settings);
   }
 };
-const version = "0.16.44";
+const version = "0.16.46";
 const __domTree = {
   Span: Span,
   Anchor: Anchor,