temml 0.10.3 → 0.10.5

package/src/linebreaking.js

@@ -1,4 +1,5 @@
 import mathMLTree from "./mathMLTree"
+import { DocumentFragment } from "./tree"
 
 /*
  * Neither Firefox nor Chrome support hard line breaks or soft line breaks.
@@ -25,125 +26,102 @@ import mathMLTree from "./mathMLTree"
  * much of this module.
  */
 
-export default 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"
-
+export default 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;
+      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) {

package/src/postProcess.js

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