temml 0.13.1 → 0.13.3

package/dist/temml.mjs

@@ -213,6 +213,7 @@ class Settings {
       : [Infinity, Infinity]
     );
     this.maxExpand = Math.max(0, deflt(options.maxExpand, 1000)); // number
+    this.wrapDelimiterPairs = true; // boolean
   }
 
   /**
@@ -994,8 +995,7 @@ defineSymbol(math, textord, "\u2135", "\\aleph", true);
 defineSymbol(math, textord, "\u2200", "\\forall", true);
 defineSymbol(math, textord, "\u210f", "\\hbar", true);
 defineSymbol(math, textord, "\u2203", "\\exists", true);
-// ∇ is actually a unary operator, not binary. But this works.
-defineSymbol(math, bin, "\u2207", "\\nabla", true);
+defineSymbol(math, open, "\u2207", "\\nabla", true);
 defineSymbol(math, textord, "\u266d", "\\flat", true);
 defineSymbol(math, textord, "\u2113", "\\ell", true);
 defineSymbol(math, textord, "\u266e", "\\natural", true);
@@ -1088,7 +1088,7 @@ defineSymbol(math, mathord, "\u2295", "\\Earth");
 
 // AMS Negated Binary Relations
 defineSymbol(math, rel, "\u226e", "\\nless", true);
-// Symbol names preceeded by "@" each have a corresponding macro.
+// Symbol names preceded by "@" each have a corresponding macro.
 defineSymbol(math, rel, "\u2a87", "\\lneq", true);
 defineSymbol(math, rel, "\u2268", "\\lneqq", true);
 defineSymbol(math, rel, "\u2268\ufe00", "\\lvertneqq");
@@ -1999,16 +1999,12 @@ for (let i = 0; i < 10; i++) {
  * much of this module.
  */
 
-const openDelims = "([{⌊⌈⟨⟮⎰⟦⦃";
-const closeDelims = ")]}⌋⌉⟩⟯⎱⟦⦄";
-
 function setLineBreaks(expression, wrapMode, isDisplayMode) {
   const mtrs = [];
   let mrows = [];
   let block = [];
   let numTopLevelEquals = 0;
   let i = 0;
-  let level = 0;
   while (i < expression.length) {
     while (expression[i] instanceof DocumentFragment) {
       expression.splice(i, 1, ...expression[i].children); // Expand the fragment.
@@ -2031,13 +2027,10 @@ function setLineBreaks(expression, wrapMode, isDisplayMode) {
     }
     block.push(node);
     if (node.type && node.type === "mo" && node.children.length === 1 &&
+        !(node.attributes.form && node.attributes.form === "prefix") && // unary operators
         !Object.prototype.hasOwnProperty.call(node.attributes, "movablelimits")) {
       const ch = node.children[0].text;
-      if (openDelims.indexOf(ch) > -1) {
-        level += 1;
-      } else if (closeDelims.indexOf(ch) > -1) {
-        level -= 1;
-      } else if (level === 0 && wrapMode === "=" && ch === "=") {
+      if (wrapMode === "=" && ch === "=") {
         numTopLevelEquals += 1;
         if (numTopLevelEquals > 1) {
           block.pop();
@@ -2046,7 +2039,7 @@ function setLineBreaks(expression, wrapMode, isDisplayMode) {
           mrows.push(element);
           block = [node];
         }
-      } else if (level === 0 && wrapMode === "tex" && ch !== "∇") {
+      } else if (wrapMode === "tex") {
         // Check if the following node is a \nobreak text node, e.g. "~""
         const next = i < expression.length - 1 ? expression[i + 1] : null;
         let glueIsFreeOfNobreak = true;
@@ -3068,7 +3061,7 @@ function assertSymbolNodeType(node) {
  * returns null.
  */
 function checkSymbolNodeType(node) {
-  if (node && (node.type === "atom" ||
+  if (node && (node.type === "atom" || node.type === "delimiter" ||
       Object.prototype.hasOwnProperty.call(NON_ATOMS, node.type))) {
     return node;
   }
@@ -4250,6 +4243,7 @@ defineMacro("\\upomega", "\\up@greek{\\omega}");
 // cmll package
 defineMacro("\\invamp", '\\mathbin{\\char"214b}');
 defineMacro("\\parr", '\\mathbin{\\char"214b}');
+defineMacro("\\upand", '\\mathbin{\\char"214b}'); // STIX package
 defineMacro("\\with", '\\mathbin{\\char"26}');
 defineMacro("\\multimapinv", '\\mathrel{\\char"27dc}');
 defineMacro("\\multimapboth", '\\mathrel{\\char"29df}');
@@ -6524,9 +6518,9 @@ const mathmlBuilder$9 = function(group, style) {
     }
     if (mustSquashRow) {
       // All the cell contents are \hphantom. Squash the cell.
+      // TODO: Remove the next line when Firefox no longer needs it.
+      mtr.classes.push("ff-squash"); // necessary in Firefox only.
       for (let j = 0; j < mtr.children.length; j++) {
-        mtr.children[j].style.display = "block";  // necessary in Firefox only
-        mtr.children[j].style.height = "0";       // necessary in Firefox only
         mtr.children[j].style.paddingTop = "0";
         mtr.children[j].style.paddingBottom = "0";
       }
@@ -7167,13 +7161,11 @@ defineFunction({
   },
   handler: ({ parser, funcName }, args, optArgs) => {
     // Find out if the author has defined custom delimiters
-    let delimiters = ["(", ")"];
+    let delimiters = ["(", ")"]; // default
     if (funcName === "\\bordermatrix" && optArgs[0] && optArgs[0].body) {
       const body = optArgs[0].body;
-      if (body.length === 2 && body[0].type === "atom" && body[1].type === "atom") {
-        if (body[0].family === "open" && body[1].family === "close") {
-          delimiters = [body[0].text, body[1].text];
-        }
+      if (body.length === 1 && body[0].type === "delimiter") {
+        delimiters = [body[0].left, body[0].right];
       }
     }
     // consume the opening brace
@@ -7221,6 +7213,7 @@ defineFunction({
     // That way, the arrow will be an overlay on the content.
     const phantom = new MathNode("mphantom", [buildGroup$1(group.body, style)]);
     const arrow = new MathNode("mrow", [phantom], ["tml-cancelto"]);
+    arrow.style.color = style.color;
     if (group.isCharacterBox && smalls.indexOf(group.body.body[0].text) > -1) {
       arrow.style.left = "0.1em";
       arrow.style.width = "90%";
@@ -7252,6 +7245,7 @@ defineFunction({
       dummyNode = new MathNode("mphantom", [zeroWidthNode]); // Hide it.
     }
     const toNode = buildGroup$1(group.to, style);
+    toNode.style.color = style.color;
     const zeroWidthToNode = new MathNode("mpadded", [toNode]);
     if (!group.isCharacterBox || /[f∫∑]/.test(group.body.body[0].text)) {
       const w = new MathNode("mspace", []);
@@ -7310,7 +7304,7 @@ const toHex = num => {
 
 // Colors from Tables 4.1 and 4.2 of the xcolor package.
 // Table 4.1 (lower case) RGB values are taken from chroma and xcolor.dtx.
-// Table 4.2 (Capitalizzed) values were sampled, because Chroma contains a unreliable
+// Table 4.2 (Capitalized) values were sampled, because Chroma contains a unreliable
 // conversion from cmyk to RGB. See https://tex.stackexchange.com/a/537274.
 const xcolors = JSON.parse(`{
   "Apricot": "#ffb484",
@@ -7869,7 +7863,41 @@ const delimiterSizes = {
   "\\Bigg": { mclass: "mord", size: 4 }
 };
 
-const delimiters = [
+const leftToRight = {
+  "(": ")",
+  "\\lparen": "\\rparen",
+  "[": "]",
+  "\\lbrack": "\\rbrack",
+  "\\{": "\\}",
+  "\\lbrace": "\\rbrace",
+  "⦇": "⦈",
+  "\\llparenthesis": "\\rrparenthesis",
+  "\\lfloor": "\\rfloor",
+  "\u230a": "\u230b",
+  "\\lceil": "\\rceil",
+  "\u2308": "\u2309",
+  "\\langle": "\\rangle",
+  "\u27e8": "\u27e9",
+  "\\lAngle": "\\rAngle",
+  "\u27ea": "\u27eb",
+  "\\llangle": "\\rrangle",
+  "⦉": "⦊",
+  "\\lvert": "\\rvert",
+  "\\lVert": "\\rVert",
+  "\\lgroup": "\\rgroup",
+  "\u27ee": "\u27ef",
+  "\\lmoustache": "\\rmoustache",
+  "\u23b0": "\u23b1",
+  "\\llbracket": "\\rrbracket",
+  "\u27e6": "\u27e7",
+  "\\lBrace": "\\rBrace",
+  "\u2983": "\u2984"
+};
+
+const leftDelimiterNames = new Set(Object.keys(leftToRight));
+new Set(Object.values(leftToRight));
+
+const delimiters = new Set([
   "(",
   "\\lparen",
   ")",
@@ -7925,7 +7953,7 @@ const delimiters = [
   "\\llbracket",
   "\\rrbracket",
   "\u27e6",
-  "\u27e6",
+  "\u27e7",
   "\\lBrace",
   "\\rBrace",
   "\u2983",
@@ -7944,12 +7972,12 @@ const delimiters = [
   "\\updownarrow",
   "\\Updownarrow",
   "."
-];
+]);
 
 // Export isDelimiter for benefit of parser.
-const dels = ["}", "\\left", "\\middle", "\\right"];
+const dels = new Set(["}", "\\left", "\\middle", "\\right"]);
 const isDelimiter = str => str.length > 0 &&
-  (delimiters.includes(str) || delimiterSizes[str] || dels.includes(str));
+  (delimiters.has(str) || delimiterSizes[str] || dels.has(str));
 
 // Metrics of the different sizes. Found by looking at TeX's output of
 // $\bigl| // \Bigl| \biggl| \Biggl| \showlists$
@@ -7962,11 +7990,11 @@ function checkDelimiter(delim, context) {
     delim = delim.body[0]; // Unwrap the braces
   }
   const symDelim = checkSymbolNodeType(delim);
-  if (symDelim && delimiters.includes(symDelim.text)) {
+  if (symDelim && delimiters.has(symDelim.text)) {
     // If a character is not in the MathML operator dictionary, it will not stretch.
     // Replace such characters w/characters that will stretch.
-    if (["<", "\\lt"].includes(symDelim.text)) { symDelim.text = "⟨"; }
-    if ([">", "\\gt"].includes(symDelim.text)) { symDelim.text = "⟩"; }
+    if (symDelim.text === "<" || symDelim.text === "\\lt") { symDelim.text = "⟨"; }
+    if (symDelim.text === ">" || symDelim.text === "\\gt") { symDelim.text = "⟩"; }
     return symDelim;
   } else if (symDelim) {
     throw new ParseError(`Invalid delimiter '${symDelim.text}' after '${context.funcName}'`, delim);
@@ -7976,7 +8004,16 @@ function checkDelimiter(delim, context) {
 }
 
 //                               /         \
-const needExplicitStretch = ["\u002F", "\u005C", "\\backslash", "\\vert", "|"];
+const needExplicitStretch = new Set(["\u002F", "\u005C", "\\backslash", "\u2216", "\\vert", "|"]);
+
+const makeFenceMo = (delim, mode, form, isStretchy) => {
+  const text = delim === "." ? "" : delim;
+  const node = new MathNode("mo", [makeText(text, mode)]);
+  node.setAttribute("fence", "true");
+  node.setAttribute("form", form);
+  node.setAttribute("stretchy", isStretchy ? "true" : "false");
+  return node;
+};
 
 defineFunction({
   type: "delimsizing",
@@ -8027,9 +8064,9 @@ defineFunction({
   },
   mathmlBuilder: (group) => {
     const children = [];
+    const delim = group.delim === "." ? "" : group.delim;
 
-    if (group.delim === ".") { group.delim = ""; }
-    children.push(makeText(group.delim, group.mode));
+    children.push(makeText(delim, group.mode));
 
     const node = new MathNode("mo", children);
 
@@ -8042,7 +8079,7 @@ defineFunction({
       // defaults.
       node.setAttribute("fence", "false");
     }
-    if (needExplicitStretch.includes(group.delim) || group.delim.indexOf("arrow") > -1) {
+    if (needExplicitStretch.has(delim) || delim.indexOf("arrow") > -1) {
       // We have to explicitly set stretchy to true.
       node.setAttribute("stretchy", "true");
     }
@@ -8055,7 +8092,7 @@ defineFunction({
 
 function assertParsed(group) {
   if (!group.body) {
-    throw new Error("Bug: The leftright ParseNode wasn't fully parsed.");
+    throw new Error("Bug: The delim ParseNode wasn't fully parsed.");
   }
 }
 
@@ -8086,17 +8123,10 @@ defineFunction({
     const delim = checkDelimiter(args[0], context);
 
     const parser = context.parser;
-    // Parse out the implicit body
     ++parser.leftrightDepth;
-    // parseExpression stops before '\\right' or `\\middle`
-    let body = parser.parseExpression(false, null, true);
+    let body = parser.parseExpression(false, "\\right", true);
     let nextToken = parser.fetch();
     while (nextToken.text === "\\middle") {
-      // `\middle`, from the ε-TeX package, ends one group and starts another group.
-      // We had to parse this expression with `breakOnMiddle` enabled in order
-      // to get TeX-compliant parsing of \over.
-      // But we do not want, at this point, to end on \middle, so continue
-      // to parse until we fetch a `\right`.
       parser.consume();
       const middle = parser.fetch().text;
       if (!symbols.math[middle]) {
@@ -8105,11 +8135,10 @@ defineFunction({
       checkDelimiter({ type: "atom", mode: "math", text: middle }, { funcName: "\\middle" });
       body.push({ type: "middle", mode: "math", delim: middle });
       parser.consume();
-      body = body.concat(parser.parseExpression(false, null, true));
+      body = body.concat(parser.parseExpression(false, "\\right", true));
       nextToken = parser.fetch();
     }
     --parser.leftrightDepth;
-    // Check the next token
     parser.expect("\\right", false);
     const right = assertNodeType(parser.parseFunction(), "leftright-right");
     return {
@@ -8117,35 +8146,90 @@ defineFunction({
       mode: parser.mode,
       body,
       left: delim.text,
-      right: right.delim
+      right: right.delim,
+      isStretchy: true
     };
   },
   mathmlBuilder: (group, style) => {
     assertParsed(group);
     const inner = buildExpression(group.body, style);
 
-    if (group.left === ".") { group.left = ""; }
-    const leftNode = new MathNode("mo", [makeText(group.left, group.mode)]);
-    leftNode.setAttribute("fence", "true");
-    leftNode.setAttribute("form", "prefix");
-    if (group.left === "/" || group.left === "\u005C" || group.left.indexOf("arrow") > -1) {
-      leftNode.setAttribute("stretchy", "true");
-    }
+    const leftNode = makeFenceMo(group.left, group.mode, "prefix", true);
     inner.unshift(leftNode);
 
-    if (group.right === ".") { group.right = ""; }
-    const rightNode = new MathNode("mo", [makeText(group.right, group.mode)]);
-    rightNode.setAttribute("fence", "true");
-    rightNode.setAttribute("form", "postfix");
-    if (group.right === "\u2216" || group.right.indexOf("arrow") > -1) {
-      rightNode.setAttribute("stretchy", "true");
+    const rightNode = makeFenceMo(group.right, group.mode, "postfix", true);
+    if (group.body.length > 0) {
+      const lastElement = group.body[group.body.length - 1];
+      if (lastElement.type === "color" && !lastElement.isTextColor) {
+        rightNode.setAttribute("mathcolor", lastElement.color);
+      }
+    }
+    inner.push(rightNode);
+
+    return makeRow(inner);
+  }
+});
+
+defineFunction({
+  type: "delimiter",
+  names: Array.from(leftDelimiterNames),
+  props: {
+    numArgs: 0,
+    allowedInText: true,
+    allowedInMath: true,
+    allowedInArgument: true
+  },
+  handler: ({ parser, funcName, token }) => {
+    if (parser.mode === "text") {
+      return {
+        type: "textord",
+        mode: "text",
+        text: funcName,
+        loc: token.loc
+      }
+    } else if (!parser.settings.wrapDelimiterPairs) {
+      // Treat this token as an ordinary symbol.
+      return {
+        type: "atom",
+        mode: "math",
+        family: "open",
+        loc: token.loc,
+        text: funcName
+      };
+    }
+    // Otherwise, try to wrap a pair of delimiters with an <mrow>.
+    const rightDelim = leftToRight[funcName];
+    // Parse the inner expression, looking for the corresponding right delimiter.
+    const body = parser.parseExpression(false, rightDelim, false);
+    const nextToken = parser.fetch().text;
+
+    if (nextToken !== rightDelim) {
+      // We were unable to find a matching right delimiter.
+      // Throw control back to renderToMathMLTree.
+      // It will reparse the entire expression with wrapDelimiterPairs set to false.
+      throw new ParseError("Unmatched delimiter");
     }
+    parser.consume();
+
+    return {
+      type: "delimiter",
+      mode: parser.mode,
+      body,
+      left: funcName,
+      right: rightDelim
+    };
+  },
+  mathmlBuilder: (group, style) => {
+    assertParsed(group);
+    const inner = buildExpression(group.body, style);
+
+    const leftNode = makeFenceMo(group.left, group.mode, "prefix", false);
+    inner.unshift(leftNode);
+
+    const rightNode = makeFenceMo(group.right, group.mode, "postfix", false);
     if (group.body.length > 0) {
       const lastElement = group.body[group.body.length - 1];
       if (lastElement.type === "color" && !lastElement.isTextColor) {
-        // \color is a switch. If the last element is of type "color" then
-        // the user set the \color switch and left it on.
-        // A \right delimiter turns the switch off, but the delimiter itself gets the color.
         rightNode.setAttribute("mathcolor", lastElement.color);
       }
     }
@@ -8174,20 +8258,17 @@ defineFunction({
       delim: delim.text
     };
   },
-  mathmlBuilder: (group, style) => {
+  mathmlBuilder: (group) => {
     const textNode = makeText(group.delim, group.mode);
     const middleNode = new MathNode("mo", [textNode]);
-    middleNode.setAttribute("fence", "true");
-    if (group.delim.indexOf("arrow") > -1) {
-      middleNode.setAttribute("stretchy", "true");
-    }
-    // The next line is not semantically correct, but
-    // Chromium fails to stretch if it is not there.
-    middleNode.setAttribute("form", "prefix");
-    // MathML gives 5/18em spacing to each <mo> element.
-    // \middle should get delimiter spacing instead.
-    middleNode.setAttribute("lspace", "0.05em");
-    middleNode.setAttribute("rspace", "0.05em");
+    middleNode.setAttribute("stretchy", "true");
+    middleNode.setAttribute("form", "infix");
+    if (textNode.text !== "/") {
+      // MathML gives 5/18em spacing to each <mo> element.
+      // \middle should get delimiter spacing instead.
+      middleNode.setAttribute("lspace", "0.05em");
+      middleNode.setAttribute("rspace", "0.05em");
+    }
     return middleNode;
   }
 });
@@ -8220,7 +8301,7 @@ const mathmlBuilder$7 = (group, style) => {
       break
     case "\\xcancel":
       node.setAttribute("notation", "updiagonalstrike downdiagonalstrike");
-      node.classes.push("tml-xcancel");
+      node.children.push(new MathNode("mrow", [], ["tml-cancel", "tml-xcancel"]));
       break
     // cancelto is handled in cancelto.js
     case "\\longdiv":
@@ -8354,7 +8435,7 @@ defineFunction({
 
 defineFunction({
   type: "enclose",
-  names: ["\\angl", "\\cancel", "\\bcancel", "\\xcancel", "\\sout", "\\overline",
+  names: ["\\angl", "\\cancel", "\\bcancel", "\\xcancel", "\\overline",
     "\\boxed", "\\longdiv", "\\phase"],
   props: {
     numArgs: 1
@@ -8371,6 +8452,25 @@ defineFunction({
   mathmlBuilder: mathmlBuilder$7
 });
 
+defineFunction({
+  type: "enclose",
+  names: ["\\sout"],
+  props: {
+    numArgs: 1,
+    allowedInText: true
+  },
+  handler({ parser, funcName }, args) {
+    const body = args[0];
+    return {
+      type: "enclose",
+      mode: parser.mode,
+      label: funcName,
+      body
+    };
+  },
+  mathmlBuilder: mathmlBuilder$7
+});
+
 defineFunction({
   type: "enclose",
   names: ["\\underline"],
@@ -8503,145 +8603,380 @@ defineFunction({
   }
 });
 
-const isLongVariableName = (group, font) => {
-  if (font !== "mathrm" || group.body.type !== "ordgroup" || group.body.body.length === 1) {
-    return false
-  }
-  if (group.body.body[0].type !== "mathord") { return false }
-  for (let i = 1; i < group.body.body.length; i++) {
-    const parseNodeType = group.body.body[i].type;
-    if (!(parseNodeType ===  "mathord" ||
-    (parseNodeType ===  "textord" && !isNaN(group.body.body[i].text)))) {
-      return false
-    }
-  }
-  return true
-};
-
-const mathmlBuilder$6 = (group, style) => {
-  const font = group.font;
-  const newStyle = style.withFont(font);
-  const mathGroup = buildGroup$1(group.body, newStyle);
+// Chromium does not support the MathML `mathvariant` attribute.
+// Instead, we replace ASCII characters with Unicode characters that
+// are defined in the font as bold, italic, double-struck, etc.
+// This module identifies those Unicode code points.
 
-  if (mathGroup.children.length === 0) { return mathGroup } // empty group, e.g., \mathrm{}
-  if (font === "boldsymbol" && ["mo", "mpadded", "mrow"].includes(mathGroup.type)) {
-    mathGroup.style.fontWeight = "bold";
-    return mathGroup
-  }
-  // Check if it is possible to consolidate elements into a single <mi> element.
-  if (isLongVariableName(group, font)) {
-    // This is a \mathrm{…} group. It gets special treatment because symbolsOrd.js
-    // wraps <mi> elements with <mpadded>s to work around a Firefox bug.
-    const mi = mathGroup.children[0].children[0].children
-      ? mathGroup.children[0].children[0]
-      : mathGroup.children[0];
-    delete mi.attributes.mathvariant;
-    for (let i = 1; i < mathGroup.children.length; i++) {
-      mi.children[0].text += mathGroup.children[i].children[0].children
-        ? mathGroup.children[i].children[0].children[0].text
-        : mathGroup.children[i].children[0].text;
-    }
-    // Wrap in a <mpadded> to prevent the same Firefox bug.
-    const mpadded = new MathNode("mpadded", [mi]);
-    mpadded.setAttribute("lspace", "0");
-    return mpadded
-  }
-  let canConsolidate = mathGroup.children[0].type === "mo";
-  for (let i = 1; i < mathGroup.children.length; i++) {
-    if (mathGroup.children[i].type === "mo" && font === "boldsymbol") {
-      mathGroup.children[i].style.fontWeight = "bold";
-    }
-    if (mathGroup.children[i].type !== "mi") { canConsolidate = false; }
-    const localVariant = mathGroup.children[i].attributes &&
-      mathGroup.children[i].attributes.mathvariant || "";
-    if (localVariant !== "normal") { canConsolidate = false; }
-  }
-  if (!canConsolidate) { return mathGroup }
-  // Consolidate the <mi> elements.
-  const mi = mathGroup.children[0];
-  for (let i = 1; i < mathGroup.children.length; i++) {
-    mi.children.push(mathGroup.children[i].children[0]);
-  }
-  if (mi.attributes.mathvariant && mi.attributes.mathvariant === "normal") {
-    // Workaround for a Firefox bug that renders spurious space around
-    // a <mi mathvariant="normal">
-    // Ref: https://bugs.webkit.org/show_bug.cgi?id=129097
-    // We insert a text node that contains a zero-width space and wrap in an mrow.
-    // TODO: Get rid of this <mi> workaround when the Firefox bug is fixed.
-    const bogus = new MathNode("mtext", new TextNode("\u200b"));
-    return new MathNode("mrow", [bogus, mi])
-  }
-  return mi
-};
+// First, a few helpers.
+const script = Object.freeze({
+  B: 0x20EA, // Offset from ASCII B to Unicode script B
+  E: 0x20EB,
+  F: 0x20EB,
+  H: 0x20C3,
+  I: 0x20C7,
+  L: 0x20C6,
+  M: 0x20E6,
+  R: 0x20C9,
+  e: 0x20CA,
+  g: 0x20A3,
+  o: 0x20C5
+});
 
-const fontAliases = {
-  "\\Bbb": "\\mathbb",
-  "\\bold": "\\mathbf",
-  "\\frak": "\\mathfrak",
-  "\\bm": "\\boldsymbol"
-};
+const frak = Object.freeze({
+  C: 0x20EA,
+  H: 0x20C4,
+  I: 0x20C8,
+  R: 0x20CA,
+  Z: 0x20CE
+});
 
-defineFunction({
-  type: "font",
-  names: [
-    // styles
-    "\\mathrm",
-    "\\mathit",
-    "\\mathbf",
-    "\\mathnormal",
-    "\\up@greek",
-    "\\boldsymbol",
+const bbb = Object.freeze({
+  C: 0x20BF, // blackboard bold
+  H: 0x20C5,
+  N: 0x20C7,
+  P: 0x20C9,
+  Q: 0x20C9,
+  R: 0x20CB,
+  Z: 0x20CA
+});
 
-    // families
-    "\\mathbb",
-    "\\mathcal",
-    "\\mathfrak",
-    "\\mathscr",
-    "\\mathsf",
-    "\\mathsfit",
-    "\\mathtt",
+const bold = Object.freeze({
+  "\u03f5": 0x1D2E7, // lunate epsilon
+  "\u03d1": 0x1D30C, // vartheta
+  "\u03f0": 0x1D2EE, // varkappa
+  "\u03c6": 0x1D319, // varphi
+  "\u03f1": 0x1D2EF, // varrho
+  "\u03d6": 0x1D30B  // varpi
+});
 
-    // aliases
-    "\\Bbb",
-    "\\bm",
-    "\\bold",
-    "\\frak"
-  ],
-  props: {
-    numArgs: 1,
-    allowedInArgument: true
-  },
-  handler: ({ parser, funcName }, args) => {
-    const body = normalizeArgument(args[0]);
-    let func = funcName;
-    if (func in fontAliases) {
-      func = fontAliases[func];
-    }
-    return {
-      type: "font",
-      mode: parser.mode,
-      font: func.slice(1),
-      body
-    };
-  },
-  mathmlBuilder: mathmlBuilder$6
+const boldItalic = Object.freeze({
+  "\u03f5": 0x1D35B, // lunate epsilon
+  "\u03d1": 0x1D380, // vartheta
+  "\u03f0": 0x1D362, // varkappa
+  "\u03c6": 0x1D38D, // varphi
+  "\u03f1": 0x1D363, // varrho
+  "\u03d6": 0x1D37F  // varpi
 });
 
-// Old font changing functions
-defineFunction({
-  type: "font",
-  names: ["\\rm", "\\sf", "\\tt", "\\bf", "\\it", "\\cal"],
-  props: {
-    numArgs: 0,
-    allowedInText: true
-  },
-  handler: ({ parser, funcName, breakOnTokenText }, args) => {
-    const { mode } = parser;
-    const body = parser.parseExpression(true, breakOnTokenText, true);
-    const fontStyle = `math${funcName.slice(1)}`;
+const boldsf = Object.freeze({
+  "\u03f5": 0x1D395, // lunate epsilon
+  "\u03d1": 0x1D3BA, // vartheta
+  "\u03f0": 0x1D39C, // varkappa
+  "\u03c6": 0x1D3C7, // varphi
+  "\u03f1": 0x1D39D, // varrho
+  "\u03d6": 0x1D3B9  // varpi
+});
 
-    return {
-      type: "font",
+const bisf = Object.freeze({
+  "\u03f5": 0x1D3CF, // lunate epsilon
+  "\u03d1": 0x1D3F4, // vartheta
+  "\u03f0": 0x1D3D6, // varkappa
+  "\u03c6": 0x1D401, // varphi
+  "\u03f1": 0x1D3D7, // varrho
+  "\u03d6": 0x1D3F3  // varpi
+});
+
+// Code point offsets below are derived from https://www.unicode.org/charts/PDF/U1D400.pdf
+const offset = Object.freeze({
+  upperCaseLatin: { // A-Z
+    "normal": ch =>                 { return 0 },
+    "bold": ch =>                   { return 0x1D3BF },
+    "italic": ch =>                 { return 0x1D3F3 },
+    "bold-italic": ch =>            { return 0x1D427 },
+    "script": ch =>                 { return script[ch] || 0x1D45B },
+    "script-bold": ch =>            { return 0x1D48F },
+    "fraktur": ch =>                { return frak[ch] || 0x1D4C3 },
+    "fraktur-bold": ch =>           { return 0x1D52B },
+    "double-struck": ch =>          { return bbb[ch] || 0x1D4F7 },
+    "sans-serif": ch =>             { return 0x1D55F },
+    "sans-serif-bold": ch =>        { return 0x1D593 },
+    "sans-serif-italic": ch =>      { return 0x1D5C7 },
+    "sans-serif-bold-italic": ch => { return 0x1D63C },
+    "monospace": ch =>              { return 0x1D62F }
+  },
+  lowerCaseLatin: { // a-z
+    "normal": ch =>                 { return 0 },
+    "bold": ch =>                   { return 0x1D3B9 },
+    "italic": ch =>                 { return ch === "h" ? 0x20A6 : 0x1D3ED },
+    "bold-italic": ch =>            { return 0x1D421 },
+    "script": ch =>                 { return script[ch] || 0x1D455 },
+    "script-bold": ch =>            { return 0x1D489 },
+    "fraktur": ch =>                { return 0x1D4BD },
+    "fraktur-bold": ch =>           { return 0x1D525 },
+    "double-struck": ch =>          { return 0x1D4F1 },
+    "sans-serif": ch =>             { return 0x1D559 },
+    "sans-serif-bold": ch =>        { return 0x1D58D },
+    "sans-serif-italic": ch =>      { return 0x1D5C1 },
+    "sans-serif-bold-italic": ch => { return 0x1D5F5 },
+    "monospace": ch =>              { return 0x1D629 }
+  },
+  upperCaseGreek: { // A-Ω
+    "normal": ch =>                 { return 0 },
+    "bold": ch =>                   { return 0x1D317 },
+    "italic": ch =>                 { return 0x1D351 },
+    // \boldsymbol actually returns upright bold for upperCaseGreek
+    "bold-italic": ch =>            { return 0x1D317 },
+    "script": ch =>                 { return 0 },
+    "script-bold": ch =>            { return 0 },
+    "fraktur": ch =>                { return 0 },
+    "fraktur-bold": ch =>           { return 0 },
+    "double-struck": ch =>          { return 0 },
+    // Unicode has no code points for regular-weight san-serif Greek. Use bold.
+    "sans-serif": ch =>             { return 0x1D3C5 },
+    "sans-serif-bold": ch =>        { return 0x1D3C5 },
+    "sans-serif-italic": ch =>      { return 0 },
+    "sans-serif-bold-italic": ch => { return 0x1D3FF },
+    "monospace": ch =>              { return 0 }
+  },
+  lowerCaseGreek: { // α-ω
+    "normal": ch =>                 { return 0 },
+    "bold": ch =>                   { return 0x1D311 },
+    "italic": ch =>                 { return 0x1D34B },
+    "bold-italic": ch =>            { return ch === "\u03d5" ? 0x1D37E : 0x1D385 },
+    "script": ch =>                 { return 0 },
+    "script-bold": ch =>            { return 0 },
+    "fraktur": ch =>                { return 0 },
+    "fraktur-bold": ch =>           { return 0 },
+    "double-struck": ch =>          { return 0 },
+    // Unicode has no code points for regular-weight san-serif Greek. Use bold.
+    "sans-serif": ch =>             { return 0x1D3BF },
+    "sans-serif-bold": ch =>        { return 0x1D3BF },
+    "sans-serif-italic": ch =>      { return 0 },
+    "sans-serif-bold-italic": ch => { return 0x1D3F9 },
+    "monospace": ch =>              { return 0 }
+  },
+  varGreek: { // \varGamma, etc
+    "normal": ch =>                 { return 0 },
+    "bold": ch =>                   { return  bold[ch] || -51 },
+    "italic": ch =>                 { return 0 },
+    "bold-italic": ch =>            { return boldItalic[ch] || 0x3A },
+    "script": ch =>                 { return 0 },
+    "script-bold": ch =>            { return 0 },
+    "fraktur": ch =>                { return 0 },
+    "fraktur-bold": ch =>           { return 0 },
+    "double-struck": ch =>          { return 0 },
+    "sans-serif": ch =>             { return boldsf[ch] || 0x74 },
+    "sans-serif-bold": ch =>        { return boldsf[ch] || 0x74 },
+    "sans-serif-italic": ch =>      { return 0 },
+    "sans-serif-bold-italic": ch => { return bisf[ch] || 0xAE },
+    "monospace": ch =>              { return 0 }
+  },
+  numeral: { // 0-9
+    "normal": ch =>                 { return 0 },
+    "bold": ch =>                   { return 0x1D79E },
+    "italic": ch =>                 { return 0 },
+    "bold-italic": ch =>            { return 0 },
+    "script": ch =>                 { return 0 },
+    "script-bold": ch =>            { return 0 },
+    "fraktur": ch =>                { return 0 },
+    "fraktur-bold": ch =>           { return 0 },
+    "double-struck": ch =>          { return 0x1D7A8 },
+    "sans-serif": ch =>             { return 0x1D7B2 },
+    "sans-serif-bold": ch =>        { return 0x1D7BC },
+    "sans-serif-italic": ch =>      { return 0 },
+    "sans-serif-bold-italic": ch => { return 0 },
+    "monospace": ch =>              { return 0x1D7C6 }
+  }
+});
+
+const variantChar = (ch, variant) => {
+  const codePoint = ch.codePointAt(0);
+  const block = 0x40 < codePoint && codePoint < 0x5b
+    ? "upperCaseLatin"
+    : 0x60 < codePoint && codePoint < 0x7b
+    ? "lowerCaseLatin"
+    : (0x390  < codePoint && codePoint < 0x3AA)
+    ? "upperCaseGreek"
+    : 0x3B0 < codePoint && codePoint < 0x3CA || ch === "\u03d5"
+    ? "lowerCaseGreek"
+    : 0x1D6E1 < codePoint && codePoint < 0x1D6FC  || bold[ch]
+    ? "varGreek"
+    : (0x2F < codePoint && codePoint <  0x3A)
+    ? "numeral"
+    : "other";
+  return block === "other"
+    ? ch
+    : String.fromCodePoint(codePoint + offset[block][variant](ch))
+};
+
+const smallCaps = Object.freeze({
+  a: "ᴀ",
+  b: "ʙ",
+  c: "ᴄ",
+  d: "ᴅ",
+  e: "ᴇ",
+  f: "ꜰ",
+  g: "ɢ",
+  h: "ʜ",
+  i: "ɪ",
+  j: "ᴊ",
+  k: "ᴋ",
+  l: "ʟ",
+  m: "ᴍ",
+  n: "ɴ",
+  o: "ᴏ",
+  p: "ᴘ",
+  q: "ǫ",
+  r: "ʀ",
+  s: "s",
+  t: "ᴛ",
+  u: "ᴜ",
+  v: "ᴠ",
+  w: "ᴡ",
+  x: "x",
+  y: "ʏ",
+  z: "ᴢ"
+});
+
+const varNameFonts = ["mathrm", "mathit"];
+
+const isLongVariableName = (group, font) => {
+  if (!varNameFonts.includes(font) || !group.body || group.body.type !== "ordgroup" ||
+      group.body.body.length === 1) {
+    return false
+  }
+  if (group.body.body[0].type !== "mathord") { return false }
+  for (let i = 1; i < group.body.body.length; i++) {
+    const parseNodeType = group.body.body[i].type;
+    if (!(parseNodeType ===  "mathord" ||
+    (parseNodeType ===  "textord" && !isNaN(group.body.body[i].text)))) {
+      return false
+    }
+  }
+  return true
+};
+
+const mathmlBuilder$6 = (group, style) => {
+  const font = group.font;
+  const newStyle = style.withFont(font);
+  const mathGroup = buildGroup$1(group.body, newStyle);
+
+  if (mathGroup.children.length === 0) { return mathGroup } // empty group, e.g., \mathrm{}
+  if (font === "boldsymbol" && ["mo", "mpadded", "mrow"].includes(mathGroup.type)) {
+    mathGroup.style.fontWeight = "bold";
+    return mathGroup
+  }
+  // Check if it is possible to consolidate elements into a single <mi> element.
+  if (isLongVariableName(group, font)) {
+    // This is a \mathrm{…} or \mathit{…} group. It gets special treatment.
+    const mi = mathGroup.children[0].children[0].children
+      ? mathGroup.children[0].children[0]
+      : mathGroup.children[0];
+    delete mi.attributes.mathvariant;
+    for (let i = 1; i < mathGroup.children.length; i++) {
+      mi.children[0].text += mathGroup.children[i].children[0].children
+        ? mathGroup.children[i].children[0].children[0].text
+        : mathGroup.children[i].children[0].text;
+    }
+    if (font === "mathit") {
+      // Long <mi> elements are normally rendered in upright font.
+      // To get italic, we need to convert each character to the corresponding italic character.
+      mi.children[0].text = mi.children[0].text.split("")
+        .map(c => variantChar(c, "italic")).join("");
+      return mi
+    }
+    // Otherwise, font is "mathrm". Wrap in a <mpadded> to prevent a Firefox spacing bug.
+    const mpadded = new MathNode("mpadded", [mi]);
+    mpadded.setAttribute("lspace", "0");
+    return mpadded
+  }
+  let canConsolidate = mathGroup.children[0].type === "mo";
+  for (let i = 1; i < mathGroup.children.length; i++) {
+    if (mathGroup.children[i].type === "mo" && font === "boldsymbol") {
+      mathGroup.children[i].style.fontWeight = "bold";
+    }
+    if (mathGroup.children[i].type !== "mi") { canConsolidate = false; }
+    const localVariant = mathGroup.children[i].attributes &&
+      mathGroup.children[i].attributes.mathvariant || "";
+    if (localVariant !== "normal") { canConsolidate = false; }
+  }
+  if (!canConsolidate) { return mathGroup }
+  // Consolidate the <mi> elements.
+  const mi = mathGroup.children[0];
+  for (let i = 1; i < mathGroup.children.length; i++) {
+    mi.children.push(mathGroup.children[i].children[0]);
+  }
+  if (mi.attributes.mathvariant && mi.attributes.mathvariant === "normal") {
+    // Workaround for a Firefox bug that renders spurious space around
+    // a <mi mathvariant="normal">
+    // Ref: https://bugs.webkit.org/show_bug.cgi?id=129097
+    // We insert a text node that contains a zero-width space and wrap in an mrow.
+    // TODO: Get rid of this <mi> workaround when the Firefox bug is fixed.
+    const bogus = new MathNode("mtext", new TextNode("\u200b"));
+    return new MathNode("mrow", [bogus, mi])
+  }
+  return mi
+};
+
+const fontAliases = {
+  "\\Bbb": "\\mathbb",
+  "\\bold": "\\mathbf",
+  "\\frak": "\\mathfrak",
+  "\\bm": "\\boldsymbol"
+};
+
+defineFunction({
+  type: "font",
+  names: [
+    // styles
+    "\\mathrm",
+    "\\mathit",
+    "\\mathbf",
+    "\\mathnormal",
+    "\\up@greek",
+    "\\boldsymbol",
+
+    // families
+    "\\mathbb",
+    "\\mathcal",
+    "\\mathfrak",
+    "\\mathscr",
+    "\\mathsf",
+    "\\mathsfit",
+    "\\mathtt",
+
+    // aliases
+    "\\Bbb",
+    "\\bm",
+    "\\bold",
+    "\\frak"
+  ],
+  props: {
+    numArgs: 1,
+    allowedInArgument: true
+  },
+  handler: ({ parser, funcName }, args) => {
+    const body = normalizeArgument(args[0]);
+    let func = funcName;
+    if (func in fontAliases) {
+      func = fontAliases[func];
+    }
+    return {
+      type: "font",
+      mode: parser.mode,
+      font: func.slice(1),
+      body
+    };
+  },
+  mathmlBuilder: mathmlBuilder$6
+});
+
+// Old font changing functions
+defineFunction({
+  type: "font",
+  names: ["\\rm", "\\sf", "\\tt", "\\bf", "\\it", "\\cal"],
+  props: {
+    numArgs: 0,
+    allowedInText: true
+  },
+  handler: ({ parser, funcName, breakOnTokenText }, args) => {
+    const { mode } = parser;
+    const body = parser.parseExpression(true, breakOnTokenText, true);
+    const fontStyle = `math${funcName.slice(1)}`;
+
+    return {
+      type: "font",
       mode: mode,
       font: fontStyle,
       body: {
@@ -8657,22 +8992,37 @@ defineFunction({
 const stylArray = ["display", "text", "script", "scriptscript"];
 const scriptLevel = { auto: -1, display: 0, text: 0, script: 1, scriptscript: 2 };
 
+const adjustStyle = (functionSize, originalStyle) => {
+  // Figure out what style this fraction should be in based on the
+  // function used
+  let style = originalStyle;
+  if (functionSize === "display") {  //\tfrac or \cfrac
+    // Get display style as a default.
+    // If incoming style is sub/sup, use style.text() to get correct size.
+    const newSize = style.level >= StyleLevel.SCRIPT ? StyleLevel.TEXT : StyleLevel.DISPLAY;
+    style = style.withLevel(newSize);
+  } else if (functionSize === "text" &&
+    style.level === StyleLevel.DISPLAY) {
+    // We're in a \tfrac but incoming style is displaystyle, so:
+    style = style.withLevel(StyleLevel.TEXT);
+  } else if (functionSize === "auto") {
+    style = style.incrementLevel();
+  } else if (functionSize === "script") {
+    style = style.withLevel(StyleLevel.SCRIPT);
+  } else if (functionSize === "scriptscript") {
+    style = style.withLevel(StyleLevel.SCRIPTSCRIPT);
+  }
+  return style;
+};
+
 const mathmlBuilder$5 = (group, style) => {
-  // Track the scriptLevel of the numerator and denominator.
-  // We may need that info for \mathchoice or for adjusting em dimensions.
-  const childOptions = group.scriptLevel === "auto"
-    ? style.incrementLevel()
-    : group.scriptLevel === "display"
-    ? style.withLevel(StyleLevel.TEXT)
-    : group.scriptLevel === "text"
-    ? style.withLevel(StyleLevel.SCRIPT)
-    : style.withLevel(StyleLevel.SCRIPTSCRIPT);
+  style = adjustStyle(group.scriptLevel, style);
 
   // Chromium (wrongly) continues to shrink fractions beyond scriptscriptlevel.
   // So we check for levels that Chromium shrinks too small.
   // If necessary, set an explicit fraction depth.
-  const numer = buildGroup$1(group.numer, childOptions);
-  const denom = buildGroup$1(group.denom, childOptions);
+  const numer = buildGroup$1(group.numer, style);
+  const denom = buildGroup$1(group.denom, style);
   if (style.level === 3) {
     numer.style.mathDepth = "2";
     numer.setAttribute("scriptlevel", "2");
@@ -8725,6 +9075,7 @@ const mathmlBuilder$5 = (group, style) => {
 defineFunction({
   type: "genfrac",
   names: [
+    "\\cfrac",
     "\\dfrac",
     "\\frac",
     "\\tfrac",
@@ -8748,6 +9099,7 @@ defineFunction({
     let scriptLevel = "auto";
 
     switch (funcName) {
+      case "\\cfrac":
       case "\\dfrac":
       case "\\frac":
       case "\\tfrac":
@@ -8774,56 +9126,26 @@ defineFunction({
         throw new Error("Unrecognized genfrac command");
     }
 
-    switch (funcName) {
-      case "\\dfrac":
-      case "\\dbinom":
-        scriptLevel = "display";
-        break;
-      case "\\tfrac":
-      case "\\tbinom":
-        scriptLevel = "text";
-        break;
-    }
-
-    return {
-      type: "genfrac",
-      mode: parser.mode,
-      continued: false,
-      numer,
-      denom,
-      hasBarLine,
-      leftDelim,
-      rightDelim,
-      scriptLevel,
-      barSize: null
-    };
-  },
-  mathmlBuilder: mathmlBuilder$5
-});
-
-defineFunction({
-  type: "genfrac",
-  names: ["\\cfrac"],
-  props: {
-    numArgs: 2
-  },
-  handler: ({ parser, funcName }, args) => {
-    const numer = args[0];
-    const denom = args[1];
+    if (funcName === "\\cfrac" || funcName.startsWith("\\d")) {
+      scriptLevel = "display";
+    } else if (funcName.startsWith("\\t")) {
+      scriptLevel = "text";
+    }
 
     return {
       type: "genfrac",
       mode: parser.mode,
-      continued: true,
+      continued: false,
       numer,
       denom,
-      hasBarLine: true,
-      leftDelim: null,
-      rightDelim: null,
-      scriptLevel: "display",
+      hasBarLine,
+      leftDelim,
+      rightDelim,
+      scriptLevel,
       barSize: null
     };
-  }
+  },
+  mathmlBuilder: mathmlBuilder$5
 });
 
 // Infix generalized fractions -- these are not rendered directly, but replaced
@@ -9654,8 +9976,16 @@ const binrelClass = (arg) => {
   const atom = arg.type === "ordgroup" && arg.body.length && arg.body.length === 1
     ? arg.body[0]
     : arg;
-  if (atom.type === "atom" && (atom.family === "bin" || atom.family === "rel")) {
-    return "m" + atom.family;
+  if (atom.type === "atom") {
+    // BIN args are sometimes changed to OPEN, so check the original family.
+    const family = arg.body.length > 0 && arg.body[0].text && symbols.math[arg.body[0].text]
+      ? symbols.math[arg.body[0].text].group
+      : atom.family;
+    if (family === "bin" || family === "rel") {
+      return "m" + family;
+    } else {
+      return "mord";
+    }
   } else {
     return "mord";
   }
@@ -10226,6 +10556,14 @@ const mathmlBuilder$1 = (group, style) => {
       if ((node.type === "mrow" || node.type === "mpadded") && node.children.length === 1 &&
           node.children[0] instanceof MathNode) {
         node = node.children[0];
+      } else if (node.type === "mrow" && node.children.length === 2 &&
+                 node.children[0] instanceof MathNode &&
+                 node.children[1] instanceof MathNode &&
+                 node.children[1].type === "mspace" && !node.children[1].attributes.width &&
+                 node.children[1].children.length === 0) {
+        // This is a workaround for a Firefox bug that applies spacing to
+        // an <mi> with mathvariant="normal".
+        node = node.children[0];
       }
       switch (node.type) {
         case "mi":
@@ -10416,7 +10754,7 @@ defineFunction({
     const inner = buildExpression(ordargument(group.body), style);
     const phantom = new MathNode("mphantom", inner);
     const node = new MathNode("mpadded", [phantom]);
-    node.setAttribute("width", "0px");
+    node.setAttribute("width", "0.1px");
     return node;
   }
 });
@@ -11233,232 +11571,6 @@ const getVariant = function(group, style) {
   return Object.prototype.hasOwnProperty.call(fontMap, font) ? fontMap[font] : null
 };
 
-// Chromium does not support the MathML `mathvariant` attribute.
-// Instead, we replace ASCII characters with Unicode characters that
-// are defined in the font as bold, italic, double-struck, etc.
-// This module identifies those Unicode code points.
-
-// First, a few helpers.
-const script = Object.freeze({
-  B: 0x20EA, // Offset from ASCII B to Unicode script B
-  E: 0x20EB,
-  F: 0x20EB,
-  H: 0x20C3,
-  I: 0x20C7,
-  L: 0x20C6,
-  M: 0x20E6,
-  R: 0x20C9,
-  e: 0x20CA,
-  g: 0x20A3,
-  o: 0x20C5
-});
-
-const frak = Object.freeze({
-  C: 0x20EA,
-  H: 0x20C4,
-  I: 0x20C8,
-  R: 0x20CA,
-  Z: 0x20CE
-});
-
-const bbb = Object.freeze({
-  C: 0x20BF, // blackboard bold
-  H: 0x20C5,
-  N: 0x20C7,
-  P: 0x20C9,
-  Q: 0x20C9,
-  R: 0x20CB,
-  Z: 0x20CA
-});
-
-const bold = Object.freeze({
-  "\u03f5": 0x1D2E7, // lunate epsilon
-  "\u03d1": 0x1D30C, // vartheta
-  "\u03f0": 0x1D2EE, // varkappa
-  "\u03c6": 0x1D319, // varphi
-  "\u03f1": 0x1D2EF, // varrho
-  "\u03d6": 0x1D30B  // varpi
-});
-
-const boldItalic = Object.freeze({
-  "\u03f5": 0x1D35B, // lunate epsilon
-  "\u03d1": 0x1D380, // vartheta
-  "\u03f0": 0x1D362, // varkappa
-  "\u03c6": 0x1D38D, // varphi
-  "\u03f1": 0x1D363, // varrho
-  "\u03d6": 0x1D37F  // varpi
-});
-
-const boldsf = Object.freeze({
-  "\u03f5": 0x1D395, // lunate epsilon
-  "\u03d1": 0x1D3BA, // vartheta
-  "\u03f0": 0x1D39C, // varkappa
-  "\u03c6": 0x1D3C7, // varphi
-  "\u03f1": 0x1D39D, // varrho
-  "\u03d6": 0x1D3B9  // varpi
-});
-
-const bisf = Object.freeze({
-  "\u03f5": 0x1D3CF, // lunate epsilon
-  "\u03d1": 0x1D3F4, // vartheta
-  "\u03f0": 0x1D3D6, // varkappa
-  "\u03c6": 0x1D401, // varphi
-  "\u03f1": 0x1D3D7, // varrho
-  "\u03d6": 0x1D3F3  // varpi
-});
-
-// Code point offsets below are derived from https://www.unicode.org/charts/PDF/U1D400.pdf
-const offset = Object.freeze({
-  upperCaseLatin: { // A-Z
-    "normal": ch =>                 { return 0 },
-    "bold": ch =>                   { return 0x1D3BF },
-    "italic": ch =>                 { return 0x1D3F3 },
-    "bold-italic": ch =>            { return 0x1D427 },
-    "script": ch =>                 { return script[ch] || 0x1D45B },
-    "script-bold": ch =>            { return 0x1D48F },
-    "fraktur": ch =>                { return frak[ch] || 0x1D4C3 },
-    "fraktur-bold": ch =>           { return 0x1D52B },
-    "double-struck": ch =>          { return bbb[ch] || 0x1D4F7 },
-    "sans-serif": ch =>             { return 0x1D55F },
-    "sans-serif-bold": ch =>        { return 0x1D593 },
-    "sans-serif-italic": ch =>      { return 0x1D5C7 },
-    "sans-serif-bold-italic": ch => { return 0x1D63C },
-    "monospace": ch =>              { return 0x1D62F }
-  },
-  lowerCaseLatin: { // a-z
-    "normal": ch =>                 { return 0 },
-    "bold": ch =>                   { return 0x1D3B9 },
-    "italic": ch =>                 { return ch === "h" ? 0x20A6 : 0x1D3ED },
-    "bold-italic": ch =>            { return 0x1D421 },
-    "script": ch =>                 { return script[ch] || 0x1D455 },
-    "script-bold": ch =>            { return 0x1D489 },
-    "fraktur": ch =>                { return 0x1D4BD },
-    "fraktur-bold": ch =>           { return 0x1D525 },
-    "double-struck": ch =>          { return 0x1D4F1 },
-    "sans-serif": ch =>             { return 0x1D559 },
-    "sans-serif-bold": ch =>        { return 0x1D58D },
-    "sans-serif-italic": ch =>      { return 0x1D5C1 },
-    "sans-serif-bold-italic": ch => { return 0x1D5F5 },
-    "monospace": ch =>              { return 0x1D629 }
-  },
-  upperCaseGreek: { // A-Ω
-    "normal": ch =>                 { return 0 },
-    "bold": ch =>                   { return 0x1D317 },
-    "italic": ch =>                 { return 0x1D351 },
-    // \boldsymbol actually returns upright bold for upperCaseGreek
-    "bold-italic": ch =>            { return 0x1D317 },
-    "script": ch =>                 { return 0 },
-    "script-bold": ch =>            { return 0 },
-    "fraktur": ch =>                { return 0 },
-    "fraktur-bold": ch =>           { return 0 },
-    "double-struck": ch =>          { return 0 },
-    // Unicode has no code points for regular-weight san-serif Greek. Use bold.
-    "sans-serif": ch =>             { return 0x1D3C5 },
-    "sans-serif-bold": ch =>        { return 0x1D3C5 },
-    "sans-serif-italic": ch =>      { return 0 },
-    "sans-serif-bold-italic": ch => { return 0x1D3FF },
-    "monospace": ch =>              { return 0 }
-  },
-  lowerCaseGreek: { // α-ω
-    "normal": ch =>                 { return 0 },
-    "bold": ch =>                   { return 0x1D311 },
-    "italic": ch =>                 { return 0x1D34B },
-    "bold-italic": ch =>            { return ch === "\u03d5" ? 0x1D37E : 0x1D385 },
-    "script": ch =>                 { return 0 },
-    "script-bold": ch =>            { return 0 },
-    "fraktur": ch =>                { return 0 },
-    "fraktur-bold": ch =>           { return 0 },
-    "double-struck": ch =>          { return 0 },
-    // Unicode has no code points for regular-weight san-serif Greek. Use bold.
-    "sans-serif": ch =>             { return 0x1D3BF },
-    "sans-serif-bold": ch =>        { return 0x1D3BF },
-    "sans-serif-italic": ch =>      { return 0 },
-    "sans-serif-bold-italic": ch => { return 0x1D3F9 },
-    "monospace": ch =>              { return 0 }
-  },
-  varGreek: { // \varGamma, etc
-    "normal": ch =>                 { return 0 },
-    "bold": ch =>                   { return  bold[ch] || -51 },
-    "italic": ch =>                 { return 0 },
-    "bold-italic": ch =>            { return boldItalic[ch] || 0x3A },
-    "script": ch =>                 { return 0 },
-    "script-bold": ch =>            { return 0 },
-    "fraktur": ch =>                { return 0 },
-    "fraktur-bold": ch =>           { return 0 },
-    "double-struck": ch =>          { return 0 },
-    "sans-serif": ch =>             { return boldsf[ch] || 0x74 },
-    "sans-serif-bold": ch =>        { return boldsf[ch] || 0x74 },
-    "sans-serif-italic": ch =>      { return 0 },
-    "sans-serif-bold-italic": ch => { return bisf[ch] || 0xAE },
-    "monospace": ch =>              { return 0 }
-  },
-  numeral: { // 0-9
-    "normal": ch =>                 { return 0 },
-    "bold": ch =>                   { return 0x1D79E },
-    "italic": ch =>                 { return 0 },
-    "bold-italic": ch =>            { return 0 },
-    "script": ch =>                 { return 0 },
-    "script-bold": ch =>            { return 0 },
-    "fraktur": ch =>                { return 0 },
-    "fraktur-bold": ch =>           { return 0 },
-    "double-struck": ch =>          { return 0x1D7A8 },
-    "sans-serif": ch =>             { return 0x1D7B2 },
-    "sans-serif-bold": ch =>        { return 0x1D7BC },
-    "sans-serif-italic": ch =>      { return 0 },
-    "sans-serif-bold-italic": ch => { return 0 },
-    "monospace": ch =>              { return 0x1D7C6 }
-  }
-});
-
-const variantChar = (ch, variant) => {
-  const codePoint = ch.codePointAt(0);
-  const block = 0x40 < codePoint && codePoint < 0x5b
-    ? "upperCaseLatin"
-    : 0x60 < codePoint && codePoint < 0x7b
-    ? "lowerCaseLatin"
-    : (0x390  < codePoint && codePoint < 0x3AA)
-    ? "upperCaseGreek"
-    : 0x3B0 < codePoint && codePoint < 0x3CA || ch === "\u03d5"
-    ? "lowerCaseGreek"
-    : 0x1D6E1 < codePoint && codePoint < 0x1D6FC  || bold[ch]
-    ? "varGreek"
-    : (0x2F < codePoint && codePoint <  0x3A)
-    ? "numeral"
-    : "other";
-  return block === "other"
-    ? ch
-    : String.fromCodePoint(codePoint + offset[block][variant](ch))
-};
-
-const smallCaps = Object.freeze({
-  a: "ᴀ",
-  b: "ʙ",
-  c: "ᴄ",
-  d: "ᴅ",
-  e: "ᴇ",
-  f: "ꜰ",
-  g: "ɢ",
-  h: "ʜ",
-  i: "ɪ",
-  j: "ᴊ",
-  k: "ᴋ",
-  l: "ʟ",
-  m: "ᴍ",
-  n: "ɴ",
-  o: "ᴏ",
-  p: "ᴘ",
-  q: "ǫ",
-  r: "ʀ",
-  s: "s",
-  t: "ᴛ",
-  u: "ᴜ",
-  v: "ᴠ",
-  w: "ᴡ",
-  x: "x",
-  y: "ʏ",
-  z: "ᴢ"
-});
-
 // "mathord" and "textord" ParseNodes created in Parser.js from symbol Groups in
 // src/symbols.js.
 
@@ -11496,8 +11608,8 @@ defineFunctionBuilders({
       node.setAttribute("mathvariant", "normal");
       if (text.text.length === 1) {
         // A Firefox bug will apply spacing here, but there should be none. Fix it.
-        node = new MathNode("mpadded", [node]);
-        node.setAttribute("lspace", "0");
+        const mspace = new MathNode("mspace", []);
+        node = new MathNode("mrow", [node, mspace]);
       }
     }
     return node
@@ -12078,7 +12190,7 @@ class MacroExpander {
     this.pushToken(new Token("EOF", end.loc));
 
     this.pushTokens(tokens);
-    return start.range(end, "");
+    return new Token("", SourceLocation.range(start, end));
   }
 
   /**
@@ -13034,7 +13146,7 @@ class Parser {
    * Parses an "expression", which is a list of atoms.
    *
    * `breakOnInfix`: Should the parsing stop when we hit infix nodes? This
-   *                 happens when functions have higher precedence han infix
+   *                 happens when functions have higher precedence than infix
    *                 nodes in implicit parses.
    *
    * `breakOnTokenText`: The text of the token that the expression should end
@@ -13642,7 +13754,7 @@ class Parser {
   ) {
     const firstToken = this.fetch();
     const text = firstToken.text;
-
+    if (name === "argument to '\\left'") { return this.parseSymbol() }
     let result;
     // Try to parse an open brace or \begingroup
     if (text === "{" || text === "\\begingroup" || text === "\\toggle") {
@@ -13789,7 +13901,8 @@ class Parser {
     let symbol;
     if (symbols[this.mode][text]) {
       let group = symbols[this.mode][text].group;
-      if (group === "bin" && binLeftCancellers.includes(this.prevAtomType)) {
+      if (group === "bin" &&
+        (binLeftCancellers.includes(this.prevAtomType) || this.prevAtomType === "")) {
         // Change from a binary operator to a unary (prefix) operator
         group = "open";
       }
@@ -13885,11 +13998,27 @@ const parseTree = function(toParse, settings) {
   if (!(typeof toParse === "string" || toParse instanceof String)) {
     throw new TypeError("Temml can only parse string typed expression")
   }
-  const parser = new Parser(toParse, settings);
-  // Blank out any \df@tag to avoid spurious "Duplicate \tag" errors
-  delete parser.gullet.macros.current["\\df@tag"];
+  let tree;
+  let parser;
+  try {
+    parser = new Parser(toParse, settings);
+    // Blank out any \df@tag to avoid spurious "Duplicate \tag" errors
+    delete parser.gullet.macros.current["\\df@tag"];
 
-  let tree = parser.parse();
+    tree = parser.parse();
+  } catch (error) {
+    if (error.toString() === "ParseError:  Unmatched delimiter") {
+      // Abandon the attempt to wrap delimiter pairs in an <mrow>.
+      // Try again, and put each delimiter into an <mo> element.
+      settings.wrapDelimiterPairs = false;
+      parser = new Parser(toParse, settings);
+      // Blank out any \df@tag to avoid spurious "Duplicate \tag" errors
+      delete parser.gullet.macros.current["\\df@tag"];
+      tree = parser.parse();
+    } else {
+      throw error;
+    }
+  }
 
   // LaTeX ignores a \tag placed outside an AMS environment.
   if (!(tree.length > 0 &&  tree[0].type && tree[0].type === "array" && tree[0].addEqnNum)) {
@@ -14066,7 +14195,7 @@ class Style {
  * https://mit-license.org/
  */
 
-const version = "0.13.01";
+const version = "0.13.3";
 
 function postProcess(block) {
   const labelMap = {};