temml 0.13.1 → 0.13.3

package/dist/temml.js

@@ -216,6 +216,7 @@ var temml = (function () {
         : [Infinity, Infinity]
       );
       this.maxExpand = Math.max(0, deflt(options.maxExpand, 1000)); // number
+      this.wrapDelimiterPairs = true; // boolean
     }
 
     /**
@@ -997,8 +998,7 @@ var temml = (function () {
   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);
@@ -1091,7 +1091,7 @@ var temml = (function () {
 
   // 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");
@@ -2002,16 +2002,12 @@ var temml = (function () {
    * 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.
@@ -2034,13 +2030,10 @@ var temml = (function () {
       }
       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();
@@ -2049,7 +2042,7 @@ var temml = (function () {
             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;
@@ -3071,7 +3064,7 @@ var temml = (function () {
    * 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;
     }
@@ -4253,6 +4246,7 @@ var temml = (function () {
   // 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}');
@@ -4613,9 +4607,9 @@ var temml = (function () {
       }
       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";
         }
@@ -5256,13 +5250,11 @@ var temml = (function () {
     },
     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
@@ -5310,6 +5302,7 @@ var temml = (function () {
       // 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%";
@@ -5341,6 +5334,7 @@ var temml = (function () {
         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", []);
@@ -5399,7 +5393,7 @@ var temml = (function () {
 
   // 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",
@@ -5958,7 +5952,41 @@ var temml = (function () {
     "\\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",
     ")",
@@ -6014,7 +6042,7 @@ var temml = (function () {
     "\\llbracket",
     "\\rrbracket",
     "\u27e6",
-    "\u27e6",
+    "\u27e7",
     "\\lBrace",
     "\\rBrace",
     "\u2983",
@@ -6033,12 +6061,12 @@ var temml = (function () {
     "\\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$
@@ -6051,11 +6079,11 @@ var temml = (function () {
       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);
@@ -6065,7 +6093,16 @@ var temml = (function () {
   }
 
   //                               /         \
-  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",
@@ -6116,9 +6153,9 @@ var temml = (function () {
     },
     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);
 
@@ -6131,7 +6168,7 @@ var temml = (function () {
         // 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");
       }
@@ -6144,7 +6181,7 @@ var temml = (function () {
 
   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.");
     }
   }
 
@@ -6175,17 +6212,10 @@ var temml = (function () {
       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]) {
@@ -6194,11 +6224,10 @@ var temml = (function () {
         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 {
@@ -6206,35 +6235,90 @@ var temml = (function () {
         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);
         }
       }
@@ -6263,20 +6347,17 @@ var temml = (function () {
         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;
     }
   });
@@ -6309,7 +6390,7 @@ var temml = (function () {
         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":
@@ -6443,7 +6524,7 @@ var temml = (function () {
 
   defineFunction({
     type: "enclose",
-    names: ["\\angl", "\\cancel", "\\bcancel", "\\xcancel", "\\sout", "\\overline",
+    names: ["\\angl", "\\cancel", "\\bcancel", "\\xcancel", "\\overline",
       "\\boxed", "\\longdiv", "\\phase"],
     props: {
       numArgs: 1
@@ -6460,6 +6541,25 @@ var temml = (function () {
     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"],
@@ -6592,8 +6692,237 @@ var temml = (function () {
     }
   });
 
+  // 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: "ᴢ"
+  });
+
+  const varNameFonts = ["mathrm", "mathit"];
+
   const isLongVariableName = (group, font) => {
-    if (font !== "mathrm" || group.body.type !== "ordgroup" || group.body.body.length === 1) {
+    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 }
@@ -6619,8 +6948,7 @@ var temml = (function () {
     }
     // 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.
+      // 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];
@@ -6630,7 +6958,14 @@ var temml = (function () {
           ? mathGroup.children[i].children[0].children[0].text
           : mathGroup.children[i].children[0].text;
       }
-      // Wrap in a <mpadded> to prevent the same Firefox bug.
+      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
@@ -6746,22 +7081,37 @@ var temml = (function () {
   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");
@@ -6814,6 +7164,7 @@ var temml = (function () {
   defineFunction({
     type: "genfrac",
     names: [
+      "\\cfrac",
       "\\dfrac",
       "\\frac",
       "\\tfrac",
@@ -6837,6 +7188,7 @@ var temml = (function () {
       let scriptLevel = "auto";
 
       switch (funcName) {
+        case "\\cfrac":
         case "\\dfrac":
         case "\\frac":
         case "\\tfrac":
@@ -6863,56 +7215,26 @@ var temml = (function () {
           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
@@ -7743,8 +8065,16 @@ var temml = (function () {
     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";
     }
@@ -8315,6 +8645,14 @@ var temml = (function () {
         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":
@@ -8505,7 +8843,7 @@ var temml = (function () {
       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;
     }
   });
@@ -9322,232 +9660,6 @@ var temml = (function () {
     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.
 
@@ -9585,8 +9697,8 @@ var temml = (function () {
         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
@@ -10167,7 +10279,7 @@ var temml = (function () {
       this.pushToken(new Token("EOF", end.loc));
 
       this.pushTokens(tokens);
-      return start.range(end, "");
+      return new Token("", SourceLocation.range(start, end));
     }
 
     /**
@@ -11123,7 +11235,7 @@ var temml = (function () {
      * 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
@@ -11731,7 +11843,7 @@ var temml = (function () {
     ) {
       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") {
@@ -11878,7 +11990,8 @@ var temml = (function () {
       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";
         }
@@ -11974,11 +12087,27 @@ var temml = (function () {
     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)) {
@@ -12155,7 +12284,7 @@ var temml = (function () {
    * https://mit-license.org/
    */
 
-  const version = "0.13.01";
+  const version = "0.13.3";
 
   function postProcess(block) {
     const labelMap = {};