katex 0.16.45 → 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,7 +310,20 @@ 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);
 }
 
 /**
@@ -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;
@@ -866,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
@@ -875,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;
@@ -911,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
@@ -1054,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 = {};
@@ -1082,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)) {
@@ -1118,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) + "\"";
   }
@@ -1168,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 || [];
   }
@@ -1197,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);
@@ -1220,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"];
@@ -1238,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) + "\"";
     }
@@ -1273,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;
@@ -1318,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);
@@ -1348,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) + "\"";
@@ -1372,6 +1452,8 @@ class SymbolNode {
  */
 class SvgNode {
   constructor(children, attributes) {
+    this.children = void 0;
+    this.attributes = void 0;
     this.children = children || [];
     this.attributes = attributes || {};
   }
@@ -1405,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
   }
@@ -1428,6 +1512,7 @@ class PathNode {
 }
 class LineNode {
   constructor(attributes) {
+    this.attributes = void 0;
     this.attributes = attributes || {};
   }
   toNode() {
@@ -3551,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
@@ -3665,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
@@ -3752,6 +3837,7 @@ const extraCharacterMap = {
   'ю': 'm',
   'я': 'r'
 };
+
 /**
  * This function adds new font metrics to default metricMap
  * It can also override existing metrics
@@ -3849,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": {}
@@ -4409,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);
@@ -4612,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);
 
@@ -4701,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);
@@ -4833,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;
@@ -4918,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",
@@ -4941,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));
@@ -4985,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");
@@ -5302,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";
@@ -5321,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";
@@ -5549,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 {
@@ -5761,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;
     }
@@ -5849,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
@@ -6006,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 || [];
@@ -6094,6 +6204,7 @@ class MathNode {
  */
 class TextNode {
   constructor(text) {
+    this.text = void 0;
     this.text = text;
   }
 
@@ -6130,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
@@ -6229,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)) {
@@ -6399,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 + "'");
   }
@@ -6448,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
@@ -6493,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.
@@ -6505,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;
@@ -6512,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;
@@ -6727,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.
  */
@@ -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;
@@ -14457,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;
@@ -14527,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 = [];
@@ -15630,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);
@@ -16176,6 +16377,7 @@ const uSubsAndSups = Object.freeze({
 
 
 
+
 // Pre-evaluate both modules as unicodeSymbols require String.normalize()
 const unicodeAccents = {
   "́": {
@@ -16603,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
@@ -17107,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":
@@ -17479,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,
@@ -17498,7 +17705,6 @@ class Parser {
           text
         };
       }
-      // TODO(ts)
       symbol = s;
     } else if (text.charCodeAt(0) >= 0x80) {
       // no symbol for e.g. ^
@@ -17544,12 +17750,10 @@ class Parser {
           label: command,
           isStretchy: false,
           isShifty: true,
-          // TODO(ts)
           base: symbol
         };
       }
     }
-    // TODO(ts)
     return symbol;
   }
 }
@@ -17695,7 +17899,7 @@ const renderToHTMLTree = function (expression, options) {
     return renderError(error, expression, settings);
   }
 };
-const version = "0.16.45";
+const version = "0.16.46";
 const __domTree = {
   Span: Span,
   Anchor: Anchor,