temml 0.10.3 → 0.10.5

package/dist/temml.js

@@ -1762,125 +1762,102 @@ var temml = (function () {
    * much of this module.
    */
 
-  function setLineBreaks(expression, wrapMode, isDisplayMode, color) {
-    if (color === undefined && wrapMode !== "none") {
-      // First, make one pass through the expression and split any color nodes.
-      const upperLimit = expression.length - 1;
-      for (let i = upperLimit; i >= 0; i--) {
-        const node = expression[i];
-        if (node.type === "mstyle" && node.attributes.mathcolor) {
-          const color = node.attributes.mathcolor;
-          const fragment = setLineBreaks(node.children, wrapMode, isDisplayMode, color);
-          if (!(fragment.type && fragment.type !== "mtable")) {
-            expression.splice(i, 1, ...fragment.children);
-          }
-        }
-      }
-    }
-
-    const tagName = color ? "mstyle" : "mrow";
-
+  function setLineBreaks(expression, wrapMode, isDisplayMode) {
     const mtrs = [];
     let mrows = [];
     let block = [];
     let numTopLevelEquals = 0;
     let canBeBIN = false; // The first node cannot be an infix binary operator.
-    for (let i = 0; i < expression.length; i++) {
-      const node = expression[i];
-      if (node.type && node.type === "mstyle" && node.attributes.mathcolor) {
-        if (block.length > 0) {
-          // Start a new block. (Insert a soft linebreak.)
-          mrows.push(new mathMLTree.MathNode(tagName, block));
-        }
-        // Insert the mstyle
-        mrows.push(node);
-        block = [];
-        continue
+    let i = 0;
+    while (i < expression.length) {
+      while (expression[i] instanceof DocumentFragment) {
+        expression.splice(i, 1, ...expression[i].children); // Expand the fragment.
       }
+      const node = expression[i];
       if (node.attributes && node.attributes.linebreak &&
         node.attributes.linebreak === "newline") {
         // A hard line break. Create a <mtr> for the current block.
         if (block.length > 0) {
-          const element = new mathMLTree.MathNode(tagName, block);
-          if (color) { element.setAttribute("mathcolor", color); }
-          mrows.push(new mathMLTree.MathNode(tagName, block));
+          mrows.push(new mathMLTree.MathNode("mrow", block));
         }
         mrows.push(node);
         block = [];
         const mtd = new mathMLTree.MathNode("mtd", mrows);
+        mtd.style.textAlign = "left";
         mtrs.push(new mathMLTree.MathNode("mtr", [mtd]));
         mrows = [];
+        i += 1;
         continue
       }
       block.push(node);
-      if (node.type && node.type === "mo" && wrapMode === "=") {
-        if (node.children.length === 1 && node.children[0].text === "=") {
+      if (node.type && node.type === "mo" && node.children.length === 1) {
+        if (wrapMode === "=" && node.children[0].text === "=") {
           numTopLevelEquals += 1;
           if (numTopLevelEquals > 1) {
             block.pop();
             // Start a new block. (Insert a soft linebreak.)
-            const element = new mathMLTree.MathNode(tagName, block);
-            if (color) { element.setAttribute("mathcolor", color); }
+            const element = new mathMLTree.MathNode("mrow", block);
             mrows.push(element);
             block = [node];
           }
-        }
-      } else if (node.type && node.type === "mo" && wrapMode === "tex") {
-        // This may be a place for a soft line break.
-        if (canBeBIN && !node.attributes.form) {
-          // 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;
-          if (
-            !(
-              next &&
-              next.type === "mtext" &&
-              next.attributes.linebreak &&
-              next.attributes.linebreak === "nobreak"
-            )
-          ) {
-            // We may need to start a new block.
-            // First, put any post-operator glue on same line as operator.
-            for (let j = i + 1; j < expression.length; j++) {
-              const nd = expression[j];
-              if (
-                nd.type &&
-                nd.type === "mspace" &&
-                !(nd.attributes.linebreak && nd.attributes.linebreak === "newline")
-              ) {
-                block.push(nd);
-                i += 1;
+        } else if (wrapMode === "tex") {
+          // This may be a place for a soft line break.
+          if (canBeBIN && !node.attributes.form) {
+            // 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;
+            if (
+              !(
+                next &&
+                next.type === "mtext" &&
+                next.attributes.linebreak &&
+                next.attributes.linebreak === "nobreak"
+              )
+            ) {
+              // We may need to start a new block.
+              // First, put any post-operator glue on same line as operator.
+              for (let j = i + 1; j < expression.length; j++) {
+                const nd = expression[j];
                 if (
-                  nd.attributes &&
-                  nd.attributes.linebreak &&
-                  nd.attributes.linebreak === "nobreak"
+                  nd.type &&
+                  nd.type === "mspace" &&
+                  !(nd.attributes.linebreak && nd.attributes.linebreak === "newline")
                 ) {
-                  glueIsFreeOfNobreak = false;
+                  block.push(nd);
+                  i += 1;
+                  if (
+                    nd.attributes &&
+                    nd.attributes.linebreak &&
+                    nd.attributes.linebreak === "nobreak"
+                  ) {
+                    glueIsFreeOfNobreak = false;
+                  }
+                } else {
+                  break;
                 }
-              } else {
-                break;
               }
             }
+            if (glueIsFreeOfNobreak) {
+              // Start a new block. (Insert a soft linebreak.)
+              const element = new mathMLTree.MathNode("mrow", block);
+              mrows.push(element);
+              block = [];
+            }
+            canBeBIN = false;
           }
-          if (glueIsFreeOfNobreak) {
-            // Start a new block. (Insert a soft linebreak.)
-            const element = new mathMLTree.MathNode(tagName, block);
-            if (color) { element.setAttribute("mathcolor", color); }
-            mrows.push(element);
-            block = [];
-          }
-          canBeBIN = false;
+          const isOpenDelimiter = node.attributes.form && node.attributes.form === "prefix";
+          // Any operator that follows an open delimiter is unary.
+          canBeBIN = !(node.attributes.separator || isOpenDelimiter);
+        } else {
+          canBeBIN = true;
         }
-        const isOpenDelimiter = node.attributes.form && node.attributes.form === "prefix";
-        // Any operator that follows an open delimiter is unary.
-        canBeBIN = !(node.attributes.separator || isOpenDelimiter);
       } else {
         canBeBIN = true;
       }
+      i += 1;
     }
     if (block.length > 0) {
-      const element = new mathMLTree.MathNode(tagName, block);
-      if (color) { element.setAttribute("mathcolor", color); }
+      const element = new mathMLTree.MathNode("mrow", block);
       mrows.push(element);
     }
     if (mtrs.length > 0) {
@@ -1967,6 +1944,48 @@ var temml = (function () {
     return mtext
   };
 
+  const numberRegEx$1 = /^[0-9]$/;
+  const isCommaOrDot = node => {
+    return (node.type === "atom" && node.text === ",") ||
+           (node.type === "textord" && node.text === ".")
+  };
+  const consolidateNumbers = expression => {
+    // Consolidate adjacent numbers. We want to return <mn>1,506.3</mn>,
+    // not <mn>1</mn><mo>,</mo><mn>5</mn><mn>0</mn><mn>6</mn><mi>.</mi><mn>3</mn>
+    if (expression.length < 2) { return }
+    const nums = [];
+    let inNum = false;
+    // Find adjacent numerals
+    for (let i = 0; i < expression.length; i++) {
+      const node = expression[i];
+      if (node.type === "textord" && numberRegEx$1.test(node.text)) {
+        if (!inNum) { nums.push({ start: i }); }
+        inNum = true;
+      } else {
+        if (inNum) { nums[nums.length - 1].end = i - 1; }
+        inNum = false;
+      }
+    }
+    if (inNum) { nums[nums.length - 1].end = expression.length - 1; }
+
+    // Determine if numeral groups are separated by a comma or dot.
+    for (let i = nums.length - 1; i > 0; i--) {
+      if (nums[i - 1].end === nums[i].start - 2 && isCommaOrDot(expression[nums[i].start - 1])) {
+        // Merge the two groups.
+        nums[i - 1].end = nums[i].end;
+        nums.splice(i, 1);
+      }
+    }
+
+    // Consolidate the number nodes
+    for (let i = nums.length - 1; i >= 0; i--) {
+      for (let j = nums[i].start + 1; j <= nums[i].end; j++) {
+        expression[nums[i].start].text += expression[j].text;
+      }
+      expression.splice(nums[i].start + 1, nums[i].end - nums[i].start);
+    }
+  };
+
   /**
    * 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.
@@ -2002,6 +2021,8 @@ var temml = (function () {
       return [group];
     }
 
+    consolidateNumbers(expression);
+
     const groups = [];
     for (let i = 0; i < expression.length; i++) {
       const group = buildGroup$1(expression[i], style);
@@ -3039,11 +3060,15 @@ var temml = (function () {
   };
 
   const mathmlBuilder$9 = (group, style) => {
-    const inner = buildExpression(group.body, style.withColor(group.color));
-    // Wrap with an <mstyle> element.
-    const node = wrapWithMstyle(inner);
-    node.setAttribute("mathcolor", group.color);
-    return node
+    // In LaTeX, color is not supposed to change the spacing of any node.
+    // So instead of wrapping the group in an <mstyle>, we apply
+    // the color individually to each node and return a document fragment.
+    let expr = buildExpression(group.body, style.withColor(group.color));
+    expr = expr.map(e => {
+      e.style.color = group.color;
+      return e
+    });
+    return mathMLTree.newDocumentFragment(expr)
   };
 
   defineFunction({
@@ -7644,7 +7669,7 @@ var temml = (function () {
   // "mathord" and "textord" ParseNodes created in Parser.js from symbol Groups in
   // src/symbols.js.
 
-  const numberRegEx$1 = /^\d(?:[\d,.]*\d)?$/;  // Keep in sync with numberRegEx in Parser.js
+  const numberRegEx = /^\d(?:[\d,.]*\d)?$/;
   const latinRegEx = /[A-Ba-z]/;
 
   const italicNumber = (text, variant, tag) => {
@@ -7698,7 +7723,7 @@ var temml = (function () {
       const variant = getVariant(group, style) || "normal";
 
       let node;
-      if (numberRegEx$1.test(group.text)) {
+      if (numberRegEx.test(group.text)) {
         const tag = group.mode === "text" ? "mtext" : "mn";
         if (variant === "italic" || variant === "bold-italic") {
           return italicNumber(text, variant, tag)
@@ -8011,8 +8036,7 @@ var temml = (function () {
   const tokenRegexString =
     `(${spaceRegexString}+)|` + // whitespace
     `${controlSpaceRegexString}|` +  // whitespace
-    "(number" +         // numbers (in non-strict mode)
-    "|[!-\\[\\]-\u2027\u202A-\uD7FF\uF900-\uFFFF]" + // single codepoint
+    "([!-\\[\\]-\u2027\u202A-\uD7FF\uF900-\uFFFF]" + // single codepoint
     `${combiningDiacriticalMarkString}*` + // ...plus accents
     "|[\uD800-\uDBFF][\uDC00-\uDFFF]" + // surrogate pair
     `${combiningDiacriticalMarkString}*` + // ...plus accents
@@ -8027,12 +8051,7 @@ var temml = (function () {
       // Separate accents from characters
       this.input = input;
       this.settings = settings;
-      this.tokenRegex = new RegExp(
-        // Strict Temml, like TeX, lexes one numeral at a time.
-        // Default Temml lexes contiguous numerals into a single <mn> element.
-        tokenRegexString.replace("number|", settings.strict ? "" : "\\d(?:[\\d,.]*\\d)?|"),
-        "g"
-      );
+      this.tokenRegex = new RegExp(tokenRegexString, 'g');
       // Category codes. The lexer only supports comment characters (14) for now.
       // MacroExpander additionally distinguishes active (13).
       this.catcodes = {
@@ -9900,8 +9919,6 @@ var temml = (function () {
 
   /* eslint no-constant-condition:0 */
 
-  const numberRegEx = /^\d(?:[\d,.]*\d)?$/;  // Keep in sync with numberRegEx in symbolsOrd.js
-
   /**
    * 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
@@ -10823,15 +10840,6 @@ var temml = (function () {
           };
         }
         symbol = s;
-      } else if (!this.strict && numberRegEx.test(text)) {
-        // A number. Wrap in a <mn> if in math mode; <mtext> otherwise.
-        this.consume();
-        return {
-          type: "textord",
-          mode: this.mode,
-          loc: SourceLocation.range(nucleus),
-          text
-        }
       } else if (text.charCodeAt(0) >= 0x80) {
         // no symbol for e.g. ^
         if (this.settings.strict) {
@@ -11071,7 +11079,7 @@ var temml = (function () {
    * https://mit-license.org/
    */
 
-  const version = "0.10.3";
+  const version = "0.10.5";
 
   function postProcess(block) {
     const labelMap = {};