temml 0.10.19 → 0.10.21

package/dist/temml.js

@@ -2073,20 +2073,22 @@ var temml = (function () {
    * 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 => {
@@ -2100,10 +2102,10 @@ var temml = (function () {
    * (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");
@@ -2133,8 +2135,8 @@ var temml = (function () {
    * 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);
   };
 
   /**
@@ -2819,7 +2821,8 @@ var temml = (function () {
         const arrowGroup = {
           type: "ordgroup",
           mode: "math",
-          body: [leftLabel, sizedArrow, rightLabel]
+          body: [leftLabel, sizedArrow, rightLabel],
+          semisimple: true
         };
         return parser.callFunction("\\\\cdparent", [arrowGroup], []);
       }
@@ -3245,7 +3248,7 @@ var temml = (function () {
       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) {
@@ -3255,15 +3258,8 @@ var temml = (function () {
         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",
@@ -3803,18 +3799,10 @@ var temml = (function () {
       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
       };
     }
   });
@@ -3843,8 +3831,7 @@ var temml = (function () {
         mode: parser.mode,
         body,
         left: delim.text,
-        right: right.delim,
-        rightColor: right.color
+        right: right.delim
       };
     },
     mathmlBuilder: (group, style) => {
@@ -3867,7 +3854,6 @@ var temml = (function () {
       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);
@@ -3941,20 +3927,12 @@ var temml = (function () {
         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":
@@ -4001,18 +3979,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) {
@@ -4210,7 +4177,7 @@ rgba(0,0,0,0) 100%);`;
     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.
@@ -4257,7 +4224,9 @@ rgba(0,0,0,0) 100%);`;
       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");
     }
@@ -4298,7 +4267,8 @@ rgba(0,0,0,0) 100%);`;
       cell = {
         type: "ordgroup",
         mode: parser.mode,
-        body: cell
+        body: cell,
+        semisimple: true
       };
       row.push(cell);
       const next = parser.fetch().text;
@@ -5131,7 +5101,7 @@ rgba(0,0,0,0) 100%);`;
     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
     }
@@ -6488,10 +6458,10 @@ rgba(0,0,0,0) 100%);`;
     },
     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)
       }
     }
   });
@@ -6511,6 +6481,13 @@ rgba(0,0,0,0) 100%);`;
   // 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;
 
@@ -6522,9 +6499,11 @@ rgba(0,0,0,0) 100%);`;
       } 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))]);
@@ -6644,6 +6623,7 @@ rgba(0,0,0,0) 100%);`;
         limits: true,
         parentIsSupSub: false,
         symbol: isSymbol,
+        fromMathOp: true,
         stack: false,
         name: isSymbol ? arr[0].text : null,
         body: isSymbol ? null : ordargument(body)
@@ -6977,7 +6957,7 @@ rgba(0,0,0,0) 100%);`;
   defineFunctionBuilders({
     type: "ordgroup",
     mathmlBuilder(group, style) {
-      return buildExpressionRow(group.body, style, true);
+      return buildExpressionRow(group.body, style, group.semisimple);
     }
   });
 
@@ -10106,6 +10086,8 @@ rgba(0,0,0,0) 100%);`;
 
   /* 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
@@ -10875,8 +10857,7 @@ rgba(0,0,0,0) 100%);`;
           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 {
@@ -10990,7 +10971,11 @@ rgba(0,0,0,0) 100%);`;
       // 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 )) {
@@ -11260,7 +11245,7 @@ rgba(0,0,0,0) 100%);`;
    * https://mit-license.org/
    */
 
-  const version = "0.10.19";
+  const version = "0.10.21";
 
   function postProcess(block) {
     const labelMap = {};