temml 0.10.19 → 0.10.21

package/dist/temml.mjs

@@ -2070,20 +2070,22 @@ const consolidateNumbers = expression => {
  * Wrap the given array of nodes in an <mrow> node if needed, i.e.,
  * unless the array has length 1.  Always returns a single node.
  */
-const makeRow = function(body) {
+const makeRow = function(body, semisimple = false) {
   if (body.length === 1 && !(body[0] instanceof DocumentFragment)) {
     return body[0];
-  } else {
+  } else if (!semisimple) {
     // Suppress spacing on <mo> nodes at both ends of the row.
     if (body[0] instanceof MathNode && body[0].type === "mo" && !body[0].attributes.fence) {
       body[0].attributes.lspace = "0em";
+      body[0].attributes.rspace = "0em";
     }
     const end = body.length - 1;
     if (body[end] instanceof MathNode && body[end].type === "mo" && !body[end].attributes.fence) {
+      body[end].attributes.lspace = "0em";
       body[end].attributes.rspace = "0em";
     }
-    return new mathMLTree.MathNode("mrow", body);
   }
+  return new mathMLTree.MathNode("mrow", body);
 };
 
 const isRel = item => {
@@ -2097,10 +2099,10 @@ const isRel = item => {
  * (1) Suppress spacing when an author wraps an operator w/braces, as in {=}.
  * (2) Suppress spacing between two adjacent relations.
  */
-const buildExpression = function(expression, style, isOrdgroup) {
-  if (expression.length === 1) {
+const buildExpression = function(expression, style, semisimple = false) {
+  if (!semisimple && expression.length === 1) {
     const group = buildGroup$1(expression[0], style);
-    if (isOrdgroup && group instanceof MathNode && group.type === "mo") {
+    if (group instanceof MathNode && group.type === "mo") {
       // When TeX writers want to suppress spacing on an operator,
       // they often put the operator by itself inside braces.
       group.setAttribute("lspace", "0em");
@@ -2130,8 +2132,8 @@ const buildExpression = function(expression, style, isOrdgroup) {
  * Equivalent to buildExpression, but wraps the elements in an <mrow>
  * if there's more than one.  Returns a single node instead of an array.
  */
-const buildExpressionRow = function(expression, style, isOrdgroup) {
-  return makeRow(buildExpression(expression, style, isOrdgroup));
+const buildExpressionRow = function(expression, style, semisimple = false) {
+  return makeRow(buildExpression(expression, style, semisimple), semisimple);
 };
 
 /**
@@ -2816,7 +2818,8 @@ function cdArrow(arrowChar, labels, parser) {
       const arrowGroup = {
         type: "ordgroup",
         mode: "math",
-        body: [leftLabel, sizedArrow, rightLabel]
+        body: [leftLabel, sizedArrow, rightLabel],
+        semisimple: true
       };
       return parser.callFunction("\\\\cdparent", [arrowGroup], []);
     }
@@ -3242,7 +3245,7 @@ defineFunction({
     allowedInText: true,
     argTypes: ["raw", "raw"]
   },
-  handler({ parser, token }, args, optArgs) {
+  handler({ parser, breakOnTokenText, token }, args, optArgs) {
     const model = optArgs[0] && assertNodeType(optArgs[0], "raw").string;
     let color = "";
     if (model) {
@@ -3252,15 +3255,8 @@ defineFunction({
       color = validateColor(assertNodeType(args[0], "raw").string, parser.gullet.macros, token);
     }
 
-    // Set macro \current@color in current namespace to store the current
-    // color, mimicking the behavior of color.sty.
-    // This is currently used just to correctly color a \right
-    // that follows a \color command.
-    parser.gullet.macros.set("\\current@color", color);
-
     // Parse out the implicit body that should be colored.
-    // Since \color nodes should not be nested, break on \color.
-    const body = parser.parseExpression(true, "\\color");
+    const body = parser.parseExpression(true, breakOnTokenText);
 
     return {
       type: "color",
@@ -3800,18 +3796,10 @@ defineFunction({
     argTypes: ["primitive"]
   },
   handler: (context, args) => {
-    // \left case below triggers parsing of \right in
-    //   `const right = parser.parseFunction();`
-    // uses this return value.
-    const color = context.parser.gullet.macros.get("\\current@color");
-    if (color && typeof color !== "string") {
-      throw new ParseError("\\current@color set to non-string in \\right");
-    }
     return {
       type: "leftright-right",
       mode: context.parser.mode,
-      delim: checkDelimiter(args[0], context).text,
-      color // undefined if not set via \color
+      delim: checkDelimiter(args[0], context).text
     };
   }
 });
@@ -3840,8 +3828,7 @@ defineFunction({
       mode: parser.mode,
       body,
       left: delim.text,
-      right: right.delim,
-      rightColor: right.color
+      right: right.delim
     };
   },
   mathmlBuilder: (group, style) => {
@@ -3864,7 +3851,6 @@ defineFunction({
     if (group.right === "\u2216" || group.right.indexOf("arrow") > -1) {
       rightNode.setAttribute("stretchy", "true");
     }
-    if (group.rightColor) { rightNode.style.color =  group.rightColor; }
     inner.push(rightNode);
 
     return makeRow(inner);
@@ -3938,20 +3924,12 @@ const mathmlBuilder$8 = (group, style) => {
       node.style.borderBottom = "0.065em solid";
       break
     case "\\cancel":
-      node.style.background = `linear-gradient(to top left,
-rgba(0,0,0,0) 0%,
-rgba(0,0,0,0) calc(50% - 0.06em),
-rgba(0,0,0,1) 50%,
-rgba(0,0,0,0) calc(50% + 0.06em),
-rgba(0,0,0,0) 100%);`;
+      // We can't use an inline background-gradient. It does not work client-side.
+      // So set a class and put the rule in the external CSS file.
+      node.classes.push("tml-cancel");
       break
     case "\\bcancel":
-      node.style.background = `linear-gradient(to top right,
-rgba(0,0,0,0) 0%,
-rgba(0,0,0,0) calc(50% - 0.06em),
-rgba(0,0,0,1) 50%,
-rgba(0,0,0,0) calc(50% + 0.06em),
-rgba(0,0,0,0) 100%);`;
+      node.classes.push("tml-bcancel");
       break
     /*
     case "\\longdiv":
@@ -3998,18 +3976,7 @@ rgba(0,0,0,0) 100%);`;
       break
     }
     case "\\xcancel":
-      node.style.background = `linear-gradient(to top left,
-rgba(0,0,0,0) 0%,
-rgba(0,0,0,0) calc(50% - 0.06em),
-rgba(0,0,0,1) 50%,
-rgba(0,0,0,0) calc(50% + 0.06em),
-rgba(0,0,0,0) 100%),
-linear-gradient(to top right,
-rgba(0,0,0,0) 0%,
-rgba(0,0,0,0) calc(50% - 0.06em),
-rgba(0,0,0,1) 50%,
-rgba(0,0,0,0) calc(50% + 0.06em),
-rgba(0,0,0,0) 100%);`;
+      node.classes.push("tml-xcancel");
       break
   }
   if (group.backgroundColor) {
@@ -4207,7 +4174,7 @@ const getTag = (group, style, rowNum) => {
   if (tagContents) {
     // The author has written a \tag or a \notag in this row.
     if (tagContents.body) {
-      tag = buildExpressionRow(tagContents.body, style);
+      tag = buildExpressionRow(tagContents.body, style, true);
       tag.classes = ["tml-tag"];
     } else {
       // \notag. Return an empty span.
@@ -4254,7 +4221,9 @@ function parseArray(
     parser.gullet.macros.set("\\cr", "\\\\\\relax");
   }
   if (addEqnNum) {
-    parser.gullet.macros.set("\\tag", "\\env@tag{\\text{#1}}");
+    parser.gullet.macros.set("\\tag", "\\@ifstar\\envtag@literal\\envtag@paren");
+    parser.gullet.macros.set("\\envtag@paren", "\\env@tag{{(\\text{#1})}}");
+    parser.gullet.macros.set("\\envtag@literal", "\\env@tag{\\text{#1}}");
     parser.gullet.macros.set("\\notag", "\\env@notag");
     parser.gullet.macros.set("\\nonumber", "\\env@notag");
   }
@@ -4295,7 +4264,8 @@ function parseArray(
     cell = {
       type: "ordgroup",
       mode: parser.mode,
-      body: cell
+      body: cell,
+      semisimple: true
     };
     row.push(cell);
     const next = parser.fetch().text;
@@ -5128,7 +5098,7 @@ const mathmlBuilder$6 = (group, style) => {
   const mathGroup = buildGroup$1(group.body, newStyle);
 
   if (mathGroup.children.length === 0) { return mathGroup } // empty group, e.g., \mathrm{}
-  if (font === "boldsymbol" && ["mo", "mpadded"].includes(mathGroup.type)) {
+  if (font === "boldsymbol" && ["mo", "mpadded", "mrow"].includes(mathGroup.type)) {
     mathGroup.style.fontWeight = "bold";
     return mathGroup
   }
@@ -6485,10 +6455,10 @@ defineFunction({
   },
   mathmlBuilder(group, style) {
     if (group.isCharacterBox) {
-      const inner = buildExpression(group.body, style);
+      const inner = buildExpression(group.body, style, true);
       return inner[0]
     } else {
-      return buildExpressionRow(group.body, style, true)
+      return buildExpressionRow(group.body, style)
     }
   }
 });
@@ -6508,6 +6478,13 @@ const ordTypes = ["textord", "mathord", "ordgroup", "close", "leftright"];
 // NOTE: Unlike most `builders`s, this one handles not only "op", but also
 // "supsub" since some of them (like \int) can affect super/subscripting.
 
+const setSpacing = node => {
+  // The user wrote a \mathop{…} function. Change spacing from default to OP spacing.
+  // The most likely spacing for an OP is a thin space per TeXbook p170.
+  node.attributes.lspace = "0.1667em";
+  node.attributes.rspace = "0.1667em";
+};
+
 const mathmlBuilder$2 = (group, style) => {
   let node;
 
@@ -6519,9 +6496,11 @@ const mathmlBuilder$2 = (group, style) => {
     } else {
       node.setAttribute("movablelimits", "false");
     }
+    if (group.fromMathOp) { setSpacing(node); }
   } else if (group.body) {
     // This is an operator with children. Add them.
     node = new MathNode("mo", buildExpression(group.body, style));
+    if (group.fromMathOp) { setSpacing(node); }
   } else {
     // This is a text operator. Add all of the characters from the operator's name.
     node = new MathNode("mi", [new TextNode(group.name.slice(1))]);
@@ -6641,6 +6620,7 @@ defineFunction({
       limits: true,
       parentIsSupSub: false,
       symbol: isSymbol,
+      fromMathOp: true,
       stack: false,
       name: isSymbol ? arr[0].text : null,
       body: isSymbol ? null : ordargument(body)
@@ -6974,7 +6954,7 @@ defineMacro("\\operatorname",
 defineFunctionBuilders({
   type: "ordgroup",
   mathmlBuilder(group, style) {
-    return buildExpressionRow(group.body, style, true);
+    return buildExpressionRow(group.body, style, group.semisimple);
   }
 });
 
@@ -12003,6 +11983,8 @@ var unicodeSymbols = {
 
 /* eslint no-constant-condition:0 */
 
+const binLeftCancellers = ["bin", "op", "open", "punct", "rel"];
+
 /**
  * This file contains the parser used to parse out a TeX expression from the
  * input. Since TeX isn't context-free, standard parsers don't work particularly
@@ -12772,8 +12754,7 @@ class Parser {
         body: expression,
         // A group formed by \begingroup...\endgroup is a semi-simple group
         // which doesn't affect spacing in math mode, i.e., is transparent.
-        // https://tex.stackexchange.com/questions/1930/when-should-one-
-        // use-begingroup-instead-of-bgroup
+        // https://tex.stackexchange.com/questions/1930/
         semisimple: text === "\\begingroup" || undefined
       };
     } else {
@@ -12887,7 +12868,11 @@ class Parser {
     // Recognize base symbol
     let symbol;
     if (symbols[this.mode][text]) {
-      const group = symbols[this.mode][text].group;
+      let group = symbols[this.mode][text].group;
+      if (group === "bin" && binLeftCancellers.includes(this.prevAtomType)) {
+        // Change from a binary operator to a unary (prefix) operator
+        group = "open";
+      }
       const loc = SourceLocation.range(nucleus);
       let s;
       if (Object.prototype.hasOwnProperty.call(ATOMS, group )) {
@@ -13157,7 +13142,7 @@ class Style {
  * https://mit-license.org/
  */
 
-const version = "0.10.19";
+const version = "0.10.21";
 
 function postProcess(block) {
   const labelMap = {};

package/dist/temmlPostProcess.js

@@ -14,7 +14,7 @@
    * https://mit-license.org/
    */
 
-  const version = "0.10.19";
+  const version = "0.10.21";
 
   function postProcess(block) {
     const labelMap = {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "temml",
-  "version": "0.10.19",
+  "version": "0.10.21",
   "description": "TeX to MathML conversion in JavaScript.",
   "main": "dist/temml.js",
   "engines": {

package/src/Parser.js

@@ -15,6 +15,8 @@ import { isDelimiter } from "./functions/delimsizing"
 import unicodeAccents from /*preval*/ "./unicodeAccents";
 import unicodeSymbols from /*preval*/ "./unicodeSymbols";
 
+const binLeftCancellers = ["bin", "op", "open", "punct", "rel"];
+
 /**
  * This file contains the parser used to parse out a TeX expression from the
  * input. Since TeX isn't context-free, standard parsers don't work particularly
@@ -784,8 +786,7 @@ export default class Parser {
         body: expression,
         // A group formed by \begingroup...\endgroup is a semi-simple group
         // which doesn't affect spacing in math mode, i.e., is transparent.
-        // https://tex.stackexchange.com/questions/1930/when-should-one-
-        // use-begingroup-instead-of-bgroup
+        // https://tex.stackexchange.com/questions/1930/
         semisimple: text === "\\begingroup" || undefined
       };
     } else {
@@ -899,7 +900,11 @@ export default class Parser {
     // Recognize base symbol
     let symbol;
     if (symbols[this.mode][text]) {
-      const group = symbols[this.mode][text].group;
+      let group = symbols[this.mode][text].group;
+      if (group === "bin" && binLeftCancellers.includes(this.prevAtomType)) {
+        // Change from a binary operator to a unary (prefix) operator
+        group = "open"
+      }
       const loc = SourceLocation.range(nucleus);
       let s;
       if (Object.prototype.hasOwnProperty.call(ATOMS, group )) {

package/src/buildMathML.js

@@ -135,20 +135,22 @@ const consolidateNumbers = expression => {
  * Wrap the given array of nodes in an <mrow> node if needed, i.e.,
  * unless the array has length 1.  Always returns a single node.
  */
-export const makeRow = function(body) {
+export const makeRow = function(body, semisimple = false) {
   if (body.length === 1 && !(body[0] instanceof DocumentFragment)) {
     return body[0];
-  } else {
+  } else if (!semisimple) {
     // Suppress spacing on <mo> nodes at both ends of the row.
     if (body[0] instanceof MathNode && body[0].type === "mo" && !body[0].attributes.fence) {
       body[0].attributes.lspace = "0em"
+      body[0].attributes.rspace = "0em"
     }
     const end = body.length - 1
     if (body[end] instanceof MathNode && body[end].type === "mo" && !body[end].attributes.fence) {
+      body[end].attributes.lspace = "0em"
       body[end].attributes.rspace = "0em"
     }
-    return new mathMLTree.MathNode("mrow", body);
   }
+  return new mathMLTree.MathNode("mrow", body);
 };
 
 const isRel = item => {
@@ -162,10 +164,10 @@ const isRel = item => {
  * (1) Suppress spacing when an author wraps an operator w/braces, as in {=}.
  * (2) Suppress spacing between two adjacent relations.
  */
-export const buildExpression = function(expression, style, isOrdgroup) {
-  if (expression.length === 1) {
+export const buildExpression = function(expression, style, semisimple = false) {
+  if (!semisimple && expression.length === 1) {
     const group = buildGroup(expression[0], style);
-    if (isOrdgroup && group instanceof MathNode && group.type === "mo") {
+    if (group instanceof MathNode && group.type === "mo") {
       // When TeX writers want to suppress spacing on an operator,
       // they often put the operator by itself inside braces.
       group.setAttribute("lspace", "0em");
@@ -195,8 +197,8 @@ export const buildExpression = function(expression, style, isOrdgroup) {
  * Equivalent to buildExpression, but wraps the elements in an <mrow>
  * if there's more than one.  Returns a single node instead of an array.
  */
-export const buildExpressionRow = function(expression, style, isOrdgroup) {
-  return makeRow(buildExpression(expression, style, isOrdgroup));
+export const buildExpressionRow = function(expression, style, semisimple = false) {
+  return makeRow(buildExpression(expression, style, semisimple), semisimple);
 };
 
 /**

package/src/environments/array.js

@@ -44,7 +44,7 @@ const getTag = (group, style, rowNum) => {
   if (tagContents) {
     // The author has written a \tag or a \notag in this row.
     if (tagContents.body) {
-      tag = mml.buildExpressionRow(tagContents.body, style)
+      tag = mml.buildExpressionRow(tagContents.body, style, true)
       tag.classes = ["tml-tag"]
     } else {
       // \notag. Return an empty span.
@@ -91,7 +91,9 @@ function parseArray(
     parser.gullet.macros.set("\\cr", "\\\\\\relax");
   }
   if (addEqnNum) {
-    parser.gullet.macros.set("\\tag", "\\env@tag{\\text{#1}}");
+    parser.gullet.macros.set("\\tag", "\\@ifstar\\envtag@literal\\envtag@paren")
+    parser.gullet.macros.set("\\envtag@paren", "\\env@tag{{(\\text{#1})}}");
+    parser.gullet.macros.set("\\envtag@literal", "\\env@tag{\\text{#1}}")
     parser.gullet.macros.set("\\notag", "\\env@notag");
     parser.gullet.macros.set("\\nonumber", "\\env@notag")
   }
@@ -132,7 +134,8 @@ function parseArray(
     cell = {
       type: "ordgroup",
       mode: parser.mode,
-      body: cell
+      body: cell,
+      semisimple: true
     };
     row.push(cell);
     const next = parser.fetch().text;

package/src/environments/cd.js

@@ -49,7 +49,8 @@ function cdArrow(arrowChar, labels, parser) {
       const arrowGroup = {
         type: "ordgroup",
         mode: "math",
-        body: [leftLabel, sizedArrow, rightLabel]
+        body: [leftLabel, sizedArrow, rightLabel],
+        semisimple: true
       };
       return parser.callFunction("\\\\cdparent", [arrowGroup], []);
     }

package/src/functions/color.js

@@ -201,7 +201,7 @@ defineFunction({
     allowedInText: true,
     argTypes: ["raw", "raw"]
   },
-  handler({ parser, token }, args, optArgs) {
+  handler({ parser, breakOnTokenText, token }, args, optArgs) {
     const model = optArgs[0] && assertNodeType(optArgs[0], "raw").string
     let color = ""
     if (model) {
@@ -211,15 +211,8 @@ defineFunction({
       color = validateColor(assertNodeType(args[0], "raw").string, parser.gullet.macros, token)
     }
 
-    // Set macro \current@color in current namespace to store the current
-    // color, mimicking the behavior of color.sty.
-    // This is currently used just to correctly color a \right
-    // that follows a \color command.
-    parser.gullet.macros.set("\\current@color", color)
-
     // Parse out the implicit body that should be colored.
-    // Since \color nodes should not be nested, break on \color.
-    const body = parser.parseExpression(true, "\\color")
+    const body = parser.parseExpression(true, breakOnTokenText)
 
     return {
       type: "color",

package/src/functions/delimsizing.js

@@ -211,18 +211,10 @@ defineFunction({
     argTypes: ["primitive"]
   },
   handler: (context, args) => {
-    // \left case below triggers parsing of \right in
-    //   `const right = parser.parseFunction();`
-    // uses this return value.
-    const color = context.parser.gullet.macros.get("\\current@color");
-    if (color && typeof color !== "string") {
-      throw new ParseError("\\current@color set to non-string in \\right");
-    }
     return {
       type: "leftright-right",
       mode: context.parser.mode,
-      delim: checkDelimiter(args[0], context).text,
-      color // undefined if not set via \color
+      delim: checkDelimiter(args[0], context).text
     };
   }
 });
@@ -251,8 +243,7 @@ defineFunction({
       mode: parser.mode,
       body,
       left: delim.text,
-      right: right.delim,
-      rightColor: right.color
+      right: right.delim
     };
   },
   mathmlBuilder: (group, style) => {
@@ -275,7 +266,6 @@ defineFunction({
     if (group.right === "\u2216" || group.right.indexOf("arrow") > -1) {
       rightNode.setAttribute("stretchy", "true")
     }
-    if (group.rightColor) { rightNode.style.color =  group.rightColor }
     inner.push(rightNode)
 
     return mml.makeRow(inner);

package/src/functions/enclose.js

@@ -34,20 +34,12 @@ const mathmlBuilder = (group, style) => {
       node.style.borderBottom = "0.065em solid"
       break
     case "\\cancel":
-      node.style.background = `linear-gradient(to top left,
-rgba(0,0,0,0) 0%,
-rgba(0,0,0,0) calc(50% - 0.06em),
-rgba(0,0,0,1) 50%,
-rgba(0,0,0,0) calc(50% + 0.06em),
-rgba(0,0,0,0) 100%);`
+      // We can't use an inline background-gradient. It does not work client-side.
+      // So set a class and put the rule in the external CSS file.
+      node.classes.push("tml-cancel")
       break
     case "\\bcancel":
-      node.style.background = `linear-gradient(to top right,
-rgba(0,0,0,0) 0%,
-rgba(0,0,0,0) calc(50% - 0.06em),
-rgba(0,0,0,1) 50%,
-rgba(0,0,0,0) calc(50% + 0.06em),
-rgba(0,0,0,0) 100%);`
+      node.classes.push("tml-bcancel")
       break
     /*
     case "\\longdiv":
@@ -94,18 +86,7 @@ rgba(0,0,0,0) 100%);`
       break
     }
     case "\\xcancel":
-      node.style.background = `linear-gradient(to top left,
-rgba(0,0,0,0) 0%,
-rgba(0,0,0,0) calc(50% - 0.06em),
-rgba(0,0,0,1) 50%,
-rgba(0,0,0,0) calc(50% + 0.06em),
-rgba(0,0,0,0) 100%),
-linear-gradient(to top right,
-rgba(0,0,0,0) 0%,
-rgba(0,0,0,0) calc(50% - 0.06em),
-rgba(0,0,0,1) 50%,
-rgba(0,0,0,0) calc(50% + 0.06em),
-rgba(0,0,0,0) 100%);`
+      node.classes.push("tml-xcancel")
       break
   }
   if (group.backgroundColor) {

package/src/functions/font.js

@@ -8,7 +8,7 @@ const mathmlBuilder = (group, style) => {
   const mathGroup = mml.buildGroup(group.body, newStyle)
 
   if (mathGroup.children.length === 0) { return mathGroup } // empty group, e.g., \mathrm{}
-  if (font === "boldsymbol" && ["mo", "mpadded"].includes(mathGroup.type)) {
+  if (font === "boldsymbol" && ["mo", "mpadded", "mrow"].includes(mathGroup.type)) {
     mathGroup.style.fontWeight = "bold"
     return mathGroup
   }

package/src/functions/not.js

@@ -37,10 +37,10 @@ defineFunction({
   },
   mathmlBuilder(group, style) {
     if (group.isCharacterBox) {
-      const inner = mml.buildExpression(group.body, style);
+      const inner = mml.buildExpression(group.body, style, true);
       return inner[0]
     } else {
-      return mml.buildExpressionRow(group.body, style, true)
+      return mml.buildExpressionRow(group.body, style)
     }
   }
 });

package/src/functions/op.js

@@ -17,6 +17,13 @@ export const ordTypes = ["textord", "mathord", "ordgroup", "close", "leftright"]
 // NOTE: Unlike most `builders`s, this one handles not only "op", but also
 // "supsub" since some of them (like \int) can affect super/subscripting.
 
+const setSpacing = node => {
+  // The user wrote a \mathop{…} function. Change spacing from default to OP spacing.
+  // The most likely spacing for an OP is a thin space per TeXbook p170.
+  node.attributes.lspace = "0.1667em"
+  node.attributes.rspace = "0.1667em"
+}
+
 const mathmlBuilder = (group, style) => {
   let node;
 
@@ -28,9 +35,11 @@ const mathmlBuilder = (group, style) => {
     } else {
       node.setAttribute("movablelimits", "false")
     }
+    if (group.fromMathOp) { setSpacing(node) }
   } else if (group.body) {
     // This is an operator with children. Add them.
     node = new mathMLTree.MathNode("mo", mml.buildExpression(group.body, style));
+    if (group.fromMathOp) { setSpacing(node) }
   } else {
     // This is a text operator. Add all of the characters from the operator's name.
     node = new mathMLTree.MathNode("mi", [new mathMLTree.TextNode(group.name.slice(1))]);
@@ -150,6 +159,7 @@ defineFunction({
       limits: true,
       parentIsSupSub: false,
       symbol: isSymbol,
+      fromMathOp: true,
       stack: false,
       name: isSymbol ? arr[0].text : null,
       body: isSymbol ? null : ordargument(body)

package/src/functions/ordgroup.js

@@ -4,6 +4,6 @@ import * as mml from "../buildMathML";
 defineFunctionBuilders({
   type: "ordgroup",
   mathmlBuilder(group, style) {
-    return mml.buildExpressionRow(group.body, style, true);
+    return mml.buildExpressionRow(group.body, style, group.semisimple);
   }
 });

package/src/postProcess.js

@@ -8,7 +8,7 @@
  * https://mit-license.org/
  */
 
-export const version = "0.10.19";
+export const version = "0.10.21";
 
 export function postProcess(block) {
   const labelMap = {}