Run clang-format on .js files in c/b/r/chromeos/chromevox

chrome/browser/resources/chromeos/chromevox/common/math_semantic_tree.js

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 /**
  * @fileoverview A semantic tree for MathML expressions.
  *
  * This file contains functionality to compute a semantic interpretation from a
  * given MathML expression. This is a very heuristic approach that assumes a
  * fairly simple default semantic which is suitable for K-12 and simple UG
@@ skipping 80 matching lines @@
   for (var i = 0, child; child = this.childNodes[i]; i++) {
     result = result.concat(child.querySelectorAll(pred));
   }
   if (pred(this)) {
     result.unshift(this);
   }
   return result;
 };
 
 
- /**
-  * Returns an XML representation of the tree.
-  * @param {boolean=} brief If set attributes are omitted.
-  * @return {Node} The XML representation of the tree.
-  */
- cvox.SemanticTree.prototype.xml = function(brief) {
-   var dp = new DOMParser();
-   var xml = dp.parseFromString('<stree></stree>', 'text/xml');
+/**
+ * Returns an XML representation of the tree.
+ * @param {boolean=} brief If set attributes are omitted.
+ * @return {Node} The XML representation of the tree.
+ */
+cvox.SemanticTree.prototype.xml = function(brief) {
+  var dp = new DOMParser();
+  var xml = dp.parseFromString('<stree></stree>', 'text/xml');
 
-   var xmlRoot = this.root.xml(xml, brief);
-   xml.childNodes[0].appendChild(xmlRoot);
+  var xmlRoot = this.root.xml(xml, brief);
+  xml.childNodes[0].appendChild(xmlRoot);
 
-   return xml.childNodes[0];
- };
-
-
- /**
-  * An XML tree representation of the current node.
-  * @param {Document} xml The XML document.
-  * @param {boolean=} brief If set attributes are omitted.
-  * @return {Node} The XML representation of the node.
-  */
- cvox.SemanticTree.Node.prototype.xml = function(xml, brief) {
-   /**
-    * Translates a list of nodes into XML representation.
-    * @param {string} tag Name of the enclosing tag.
-    * @param {!Array<!cvox.SemanticTree.Node>} nodes A list of nodes.
-    * @return {Node} An XML representation of the node list.
-    */
-   var xmlNodeList = function(tag, nodes) {
-     var xmlNodes = nodes.map(function(x) {return x.xml(xml, brief);});
-     var tagNode = xml.createElement(tag);
-     for (var i = 0, child; child = xmlNodes[i]; i++) {
-       tagNode.appendChild(child);
-     }
-     return tagNode;
-   };
-   var node = xml.createElement(this.type);
-   if (!brief) {
-     this.xmlAttributes_(node);
-   }
-   node.textContent = this.textContent;
-   if (this.contentNodes.length > 0) {
-     node.appendChild(xmlNodeList('content', this.contentNodes));
-   }
-   if (this.childNodes.length > 0) {
-     node.appendChild(xmlNodeList('children', this.childNodes));
-   }
-   return node;
- };
+  return xml.childNodes[0];
+};
 
 
 /**
-  * Serializes the XML representation of the tree.
-  * @param {boolean=} brief If set attributes are omitted.
+ * An XML tree representation of the current node.
+ * @param {Document} xml The XML document.
+ * @param {boolean=} brief If set attributes are omitted.
+ * @return {Node} The XML representation of the node.
+ */
+cvox.SemanticTree.Node.prototype.xml = function(xml, brief) {
+  /**
+   * Translates a list of nodes into XML representation.
+   * @param {string} tag Name of the enclosing tag.
+   * @param {!Array<!cvox.SemanticTree.Node>} nodes A list of nodes.
+   * @return {Node} An XML representation of the node list.
+   */
+  var xmlNodeList = function(tag, nodes) {
+    var xmlNodes = nodes.map(function(x) {
+      return x.xml(xml, brief);
+    });
+    var tagNode = xml.createElement(tag);
+    for (var i = 0, child; child = xmlNodes[i]; i++) {
+      tagNode.appendChild(child);
+    }
+    return tagNode;
+  };
+  var node = xml.createElement(this.type);
+  if (!brief) {
+    this.xmlAttributes_(node);
+  }
+  node.textContent = this.textContent;
+  if (this.contentNodes.length > 0) {
+    node.appendChild(xmlNodeList('content', this.contentNodes));
+  }
+  if (this.childNodes.length > 0) {
+    node.appendChild(xmlNodeList('children', this.childNodes));
+  }
+  return node;
+};
+
+
+/**
+ * Serializes the XML representation of the tree.
+ * @param {boolean=} brief If set attributes are omitted.
  * @return {string} Serialized string.
  */
 cvox.SemanticTree.prototype.toString = function(brief) {
   var xmls = new XMLSerializer();
   return xmls.serializeToString(this.xml(brief));
 };
 
 
 /**
  * Pretty print the XML representation of the tree.
@@ skipping 11 matching lines @@
  * @param {string} xml The serialised XML string.
  * @return {string} The formatted string.
  */
 cvox.SemanticTree.formatXml = function(xml) {
   var reg = /(>)(<)(\/*)/g;
   xml = xml.replace(reg, '$1\r\n$2$3');
   reg = /(>)(.+)(<c)/g;
   xml = xml.replace(reg, '$1\r\n$2\r\n$3');
   var formatted = '';
   var padding = '';
-  xml.split('\r\n')
-      .forEach(function(node) {
-                 if (node.match(/.+<\/\w[^>]*>$/)) {
-                   // Node with content.
-                   formatted += padding + node + '\r\n';
-                 } else if (node.match(/^<\/\w/)) {
-                   if (padding) {
-                     // Closing tag
-                     padding = padding.slice(2);
-                     formatted += padding + node + '\r\n';
-                   }
-                 } else if (node.match(/^<\w[^>]*[^\/]>.*$/)) {
-                   // Opening tag
-                   formatted += padding + node + '\r\n';
-                   padding += '  ';
-                 } else {
-                   // Empty tag
-                   formatted += padding + node + '\r\n';
-                 }
-               });
+  xml.split('\r\n').forEach(function(node) {
+    if (node.match(/.+<\/\w[^>]*>$/)) {
+      // Node with content.
+      formatted += padding + node + '\r\n';
+    } else if (node.match(/^<\/\w/)) {
+      if (padding) {
+        // Closing tag
+        padding = padding.slice(2);
+        formatted += padding + node + '\r\n';
+      }
+    } else if (node.match(/^<\w[^>]*[^\/]>.*$/)) {
+      // Opening tag
+      formatted += padding + node + '\r\n';
+      padding += '  ';
+    } else {
+      // Empty tag
+      formatted += padding + node + '\r\n';
+    }
+  });
   return formatted;
 };
 
 
 /**
  * Serializes the XML representation of a node.
  * @param {boolean=} brief If attributes are to be omitted.
  * @return {string} Serialized string.
  */
 cvox.SemanticTree.Node.prototype.toString = function(brief) {
@@ skipping 117 matching lines @@
   var index = this.childNodes.indexOf(oldNode);
   if (index == -1) {
     return;
   }
   newNode.parent = this;
   oldNode.parent = null;
   this.childNodes[index] = newNode;
   // To not mess up the order of MathML elements more than necessary, we only
   // remove and add difference lists. The hope is that we might end up with
   // little change.
-  var removeMathml = oldNode.mathml.filter(
-      function(x) {return newNode.mathml.indexOf(x) == -1;});
-  var addMathml = newNode.mathml.filter(
-      function(x) {return oldNode.mathml.indexOf(x) == -1;});
+  var removeMathml = oldNode.mathml.filter(function(x) {
+    return newNode.mathml.indexOf(x) == -1;
+  });
+  var addMathml = newNode.mathml.filter(function(x) {
+    return oldNode.mathml.indexOf(x) == -1;
+  });
   this.removeMathmlNodes_(removeMathml);
   this.addMathmlNodes_(addMathml);
 };
 
 
 /**
  * Appends a content node to the node.
  * @param {cvox.SemanticTree.Node} node The new content node.
  * @private
  */
@@ skipping 31 matching lines @@
 cvox.SemanticTree.prototype.parseMathml_ = function(mml) {
   var children = cvox.DomUtil.toArray(mml.children);
   switch (cvox.SemanticUtil.tagName(mml)) {
     case 'MATH':
     case 'MROW':
     case 'MPADDED':
     case 'MSTYLE':
       children = cvox.SemanticUtil.purgeNodes(children);
       // Single child node, i.e. the row is meaningless.
       if (children.length == 1) {
-        return this.parseMathml_(/** @type {!Element} */(children[0]));
+        return this.parseMathml_(/** @type {!Element} */ (children[0]));
       }
       // Case of a 'meaningful' row, even if they are empty.
       return this.processRow_(this.parseMathmlChildren_(children));
-    break;
+      break;
     case 'MFRAC':
       var newNode = this.makeBranchNode_(
           cvox.SemanticAttr.Type.FRACTION,
-          [this.parseMathml_(children[0]), this.parseMathml_(children[1])],
-          []);
+          [this.parseMathml_(children[0]), this.parseMathml_(children[1])], []);
       newNode.role = cvox.SemanticAttr.Role.DIVISION;
       return newNode;
       break;
     case 'MSUB':
     case 'MSUP':
     case 'MSUBSUP':
     case 'MOVER':
     case 'MUNDER':
     case 'MUNDEROVER':
-      return this.makeLimitNode_(cvox.SemanticUtil.tagName(mml),
-                                 this.parseMathmlChildren_(children));
+      return this.makeLimitNode_(
+          cvox.SemanticUtil.tagName(mml), this.parseMathmlChildren_(children));
       break;
     case 'MROOT':
       return this.makeBranchNode_(
           cvox.SemanticAttr.Type.ROOT,
-          [this.parseMathml_(children[0]), this.parseMathml_(children[1])],
-          []);
+          [this.parseMathml_(children[0]), this.parseMathml_(children[1])], []);
       break;
     case 'MSQRT':
-      children = this.parseMathmlChildren_(
-          cvox.SemanticUtil.purgeNodes(children));
+      children =
+          this.parseMathmlChildren_(cvox.SemanticUtil.purgeNodes(children));
       return this.makeBranchNode_(
           cvox.SemanticAttr.Type.SQRT, [this.processRow_(children)], []);
       break;
     case 'MTABLE':
       newNode = this.makeBranchNode_(
-          cvox.SemanticAttr.Type.TABLE,
-          this.parseMathmlChildren_(children), []);
+          cvox.SemanticAttr.Type.TABLE, this.parseMathmlChildren_(children),
+          []);
       if (cvox.SemanticTree.tableIsMultiline_(newNode)) {
         this.tableToMultiline_(newNode);
-        }
+      }
       return newNode;
       break;
     case 'MTR':
       newNode = this.makeBranchNode_(
-          cvox.SemanticAttr.Type.ROW,
-          this.parseMathmlChildren_(children), []);
+          cvox.SemanticAttr.Type.ROW, this.parseMathmlChildren_(children), []);
       newNode.role = cvox.SemanticAttr.Role.TABLE;
       return newNode;
       break;
     case 'MTD':
-      children = this.parseMathmlChildren_(
-          cvox.SemanticUtil.purgeNodes(children));
+      children =
+          this.parseMathmlChildren_(cvox.SemanticUtil.purgeNodes(children));
       newNode = this.makeBranchNode_(
           cvox.SemanticAttr.Type.CELL, [this.processRow_(children)], []);
       newNode.role = cvox.SemanticAttr.Role.TABLE;
       return newNode;
       break;
     case 'MTEXT':
       var leaf = this.makeLeafNode_(mml);
       leaf.type = cvox.SemanticAttr.Type.TEXT;
       return leaf;
       break;
@@ skipping 16 matching lines @@
       break;
     case 'MO':
       leaf = this.makeLeafNode_(mml);
       if (leaf.type == cvox.SemanticAttr.Type.UNKNOWN) {
         leaf.type = cvox.SemanticAttr.Type.OPERATOR;
       }
       return leaf;
       break;
     // TODO (sorge) Do something useful with error and phantom symbols.
     default:
-    // Ordinarilly at this point we should not get any other tag.
+      // Ordinarilly at this point we should not get any other tag.
       return this.makeUnprocessed_(mml);
   }
 };
 
 
 /**
  * Parse a list of MathML nodes into the semantic tree.
  * @param {Array<Element>} mmls A list of MathML nodes.
  * @return {!Array<cvox.SemanticTree.Node>} The list of resulting semantic
  *     node.
@@ skipping 58 matching lines @@
  */
 cvox.SemanticTree.prototype.makeBranchNode_ = function(
     type, children, contentNodes, content) {
   var node = this.createNode_();
   if (content) {
     node.updateContent_(content);
   }
   node.type = type;
   node.childNodes = children;
   node.contentNodes = contentNodes;
-  children.concat(contentNodes)
-      .forEach(
-          function(x) {
-            x.parent = node;
-            node.addMathmlNodes_(x.mathml);
-          });
+  children.concat(contentNodes).forEach(function(x) {
+    x.parent = node;
+    node.addMathmlNodes_(x.mathml);
+  });
   return node;
 };
 
 
 /**
  * Create a branching node for an implicit operation, currently assumed to
  * be of multiplicative type.
  * @param {!Array<!cvox.SemanticTree.Node>} nodes The operands.
  * @return {!cvox.SemanticTree.Node} The new branch node.
  * @private
  */
 cvox.SemanticTree.prototype.makeImplicitNode_ = function(nodes) {
   if (nodes.length == 1) {
     return nodes[0];
-    }
+  }
   var operator = this.createNode_();
   // For now we assume this is a multiplication using invisible times.
   operator.updateContent_(cvox.SemanticAttr.invisibleTimes());
   var newNode = this.makeInfixNode_(nodes, operator);
   newNode.role = cvox.SemanticAttr.Role.IMPLICIT;
   return newNode;
 };
 
 
 /**
@@ skipping 16 matching lines @@
  * @param {!cvox.SemanticTree.Node} inner The inner node.
  * @param {!Array<cvox.SemanticTree.Node>} nodeList List of nodes.
  * @param {!cvox.SemanticAttr.Type} type The new type of the node.
  * @return {!cvox.SemanticTree.Node} The new branch node.
  * @private
  */
 cvox.SemanticTree.prototype.makeConcatNode_ = function(inner, nodeList, type) {
   if (nodeList.length == 0) {
     return inner;
   }
-  var content = nodeList.map(function(x) {return x.textContent;}).join(' ');
+  var content = nodeList
+                    .map(function(x) {
+                      return x.textContent;
+                    })
+                    .join(' ');
   var newNode = this.makeBranchNode_(type, [inner], nodeList, content);
   if (nodeList.length > 0) {
     newNode.role = cvox.SemanticAttr.Role.MULTIOP;
   }
   return newNode;
 };
 
 
 /**
  * Wraps a node into prefix operators.
@@ skipping 75 matching lines @@
   var partition = cvox.SemanticTree.partitionNodes_(
       nodes, cvox.SemanticTree.attrPred_('type', 'RELATION'));
   var firstRel = partition.rel[0];
 
   if (!firstRel) {
     return this.processOperationsInRow_(nodes);
   }
   if (nodes.length == 1) {
     return nodes[0];
   }
-  var children = partition.comp.map(
-      goog.bind(this.processOperationsInRow_, this));
-  if (partition.rel.every(
-         function(x) {return x.textContent == firstRel.textContent;})) {
+  var children =
+      partition.comp.map(goog.bind(this.processOperationsInRow_, this));
+  if (partition.rel.every(function(x) {
+        return x.textContent == firstRel.textContent;
+      })) {
     return this.makeBranchNode_(
         cvox.SemanticAttr.Type.RELSEQ, children, partition.rel,
         firstRel.textContent);
   }
   return this.makeBranchNode_(
       cvox.SemanticAttr.Type.MULTIREL, children, partition.rel);
 };
 
 
 /**
  * Constructs a syntax tree with operator precedence from a list nodes.
  * @param {!Array<!cvox.SemanticTree.Node>} nodes The list of nodes.
  * @return {!cvox.SemanticTree.Node} The root node of the syntax tree.
  * @private
  */
 cvox.SemanticTree.prototype.processOperationsInRow_ = function(nodes) {
   if (nodes.length == 0) {
     return this.makeEmptyNode_();
   }
   if (nodes.length == 1) {
     return nodes[0];
   }
 
   var prefix = [];
-  while (nodes.length > 0 &&
-      nodes[0].type == cvox.SemanticAttr.Type.OPERATOR) {
+  while (nodes.length > 0 && nodes[0].type == cvox.SemanticAttr.Type.OPERATOR) {
     prefix.push(nodes.shift());
   }
   // Pathological case: only operators in row.
   if (nodes.length == 0) {
     return this.makePrefixNode_(prefix.pop(), prefix);
   }
   if (nodes.length == 1) {
     return this.makePrefixNode_(nodes[0], prefix);
   }
 
@@ skipping 43 matching lines @@
   }
 
   var split = cvox.SemanticTree.sliceNodes_(
       nodes, cvox.SemanticTree.attrPred_('type', 'OPERATOR'));
 
   if (split.head.length == 0) {
     prefixes.push(split.div);
     return this.makeOperationsTree_(split.tail, root, lastop, prefixes);
   }
 
-  var node = this.makePrefixNode_(
-      this.makeImplicitNode_(split.head), prefixes);
+  var node = this.makePrefixNode_(this.makeImplicitNode_(split.head), prefixes);
   var newNode = this.appendOperand_(root, lastop, node);
   if (!split.div) {
     return newNode;
   }
 
   return this.makeOperationsTree_(split.tail, newNode, split.div, []);
 };
 
 // TODO (sorge) The following four functions could be combined into
 // a single one. Currently it is clearer the way it is, though.
 /**
  * Appends an operand at the right place in an operator tree.
  * @param {!cvox.SemanticTree.Node} root The operator tree.
  * @param {!cvox.SemanticTree.Node} op The operator node.
  * @param {!cvox.SemanticTree.Node} node The node to be added.
  * @return {!cvox.SemanticTree.Node} The modified root node.
  * @private
  */
 cvox.SemanticTree.prototype.appendOperand_ = function(root, op, node) {
   // In general our operator tree will have the form that additions and
   // subtractions are stacked, while multiplications are subordinate.
   if (root.type != cvox.SemanticAttr.Type.INFIXOP) {
     return this.makeInfixNode_([root, node], op);
   }
   if (this.appendExistingOperator_(root, op, node)) {
     return root;
   }
   return op.role == cvox.SemanticAttr.Role.MULTIPLICATION ?
       this.appendMultiplicativeOp_(root, op, node) :
-          this.appendAdditiveOp_(root, op, node);
+      this.appendAdditiveOp_(root, op, node);
 };
 
 
 /**
  * Appends a multiplicative operator and operand.
  * @param {!cvox.SemanticTree.Node} root The root node.
  * @param {!cvox.SemanticTree.Node} op The operator node.
  * @param {!cvox.SemanticTree.Node} node The operand node to be added.
  * @return {!cvox.SemanticTree.Node} The modified root node.
  * @private
@@ skipping 38 matching lines @@
     return false;
   }
   if (root.textContent == op.textContent) {
     root.appendContentNode_(op);
     root.appendChild_(node);
     return true;
   }
   this.appendExistingOperator_(
       // Again, if this is an INFIXOP node, we know it has a child!
       /** @type {!cvox.SemanticTree.Node} */
-      (root.childNodes[root.childNodes.length - 1]),
-      op, node);
+      (root.childNodes[root.childNodes.length - 1]), op, node);
   return false;
 };
 
 
 // TODO (sorge) The following procedure needs a rational reconstruction. It
 // contains a number of similar cases which should be combined.
 /**
  * Combines delimited expressions in a list of nodes.
  *
  * The basic idea of the heuristic is as follows:
@@ skipping 24 matching lines @@
  * @param {!Array<!Array<cvox.SemanticTree.Node>>} content FIFO queue content
  *     between fences.
  * @param {!Array<cvox.SemanticTree.Node>} openStack LIFO stack of open fences.
  * @param {!Array<!Array<cvox.SemanticTree.Node>>} contentStack LIFO stack of
  *     content between fences yet to be processed.
  * @return {!Array<cvox.SemanticTree.Node>} A list of nodes with all fenced
  *     expressions processed.
  * @private
  */
 cvox.SemanticTree.prototype.processFences_ = function(
-  fences, content, openStack, contentStack) {
+    fences, content, openStack, contentStack) {
   // Base case 1: Everything is used up.
   if (fences.length == 0 && openStack.length == 0) {
     return contentStack[0];
-    }
+  }
   var openPred = cvox.SemanticTree.attrPred_('role', 'OPEN');
   // Base case 2: Only open and neutral fences are left on the stack.
   if (fences.length == 0) {
     // Basic idea:
     // - make punctuation nodes from open fences
     // - combine as many neutral fences as possible, if the are not separated by
     //   open fences.
     // The idea is to allow for things like case statements etc. and not bury
     // them inside a neutral fenced expression.
     //
     // 0. We process the list from left to right. Hence the first element on the
     //    content stack are actually left most elements in the expression.
     // 1. Slice at open fence.
     // 2. On tail optimize for neutral fences.
     // 3. Repeat until fence stack is exhausted.
     // Push rightmost elements onto the result.
     var result = contentStack.shift();
     while (openStack.length > 0) {
       if (openPred(openStack[0])) {
         var firstOpen = openStack.shift();
         cvox.SemanticTree.fenceToPunct_(firstOpen);
         result.push(firstOpen);
       } else {
         var split = cvox.SemanticTree.sliceNodes_(openStack, openPred);
         var cutLength = split.head.length - 1;
         var innerNodes = this.processNeutralFences_(
             split.head, contentStack.slice(0, cutLength));
         contentStack = contentStack.slice(cutLength);
-        //var rightContent = contentStack.shift();
+        // var rightContent = contentStack.shift();
         result.push.apply(result, innerNodes);
-        //result.push.apply(result, rightContent);
+        // result.push.apply(result, rightContent);
         if (split.div) {
           split.tail.unshift(split.div);
         }
         openStack = split.tail;
       }
       result.push.apply(result, contentStack.shift());
     }
     return result;
   }
   var lastOpen = openStack[openStack.length - 1];
   var firstRole = fences[0].role;
   // General opening case.
   // Either we have an open fence.
   if (firstRole == cvox.SemanticAttr.Role.OPEN ||
       // Or we have a neutral fence that does not have a counter part.
-          (firstRole == cvox.SemanticAttr.Role.NEUTRAL &&
-              (!lastOpen ||
-                  fences[0].textContent != lastOpen.textContent))) {
+      (firstRole == cvox.SemanticAttr.Role.NEUTRAL &&
+       (!lastOpen || fences[0].textContent != lastOpen.textContent))) {
     openStack.push(fences.shift());
     contentStack.push(content.shift());
     return this.processFences_(fences, content, openStack, contentStack);
   }
   // General closing case.
-  if (lastOpen && (
-      // Closing fence for some opening fence.
-      (firstRole == cvox.SemanticAttr.Role.CLOSE &&
-          lastOpen.role == cvox.SemanticAttr.Role.OPEN) ||
-              // Netural fence with exact counter part.
-              (firstRole == cvox.SemanticAttr.Role.NEUTRAL &&
-                  fences[0].textContent == lastOpen.textContent))) {
+  if (lastOpen &&
+      (
+          // Closing fence for some opening fence.
+          (firstRole == cvox.SemanticAttr.Role.CLOSE &&
+           lastOpen.role == cvox.SemanticAttr.Role.OPEN) ||
+          // Netural fence with exact counter part.
+          (firstRole == cvox.SemanticAttr.Role.NEUTRAL &&
+           fences[0].textContent == lastOpen.textContent))) {
     var fenced = this.makeHorizontalFencedNode_(
         openStack.pop(), fences.shift(), contentStack.pop());
     contentStack.push(contentStack.pop().concat([fenced], content.shift()));
     return this.processFences_(fences, content, openStack, contentStack);
   }
   // Closing with a neutral fence on the stack.
   if (lastOpen && firstRole == cvox.SemanticAttr.Role.CLOSE &&
       lastOpen.role == cvox.SemanticAttr.Role.NEUTRAL &&
-          openStack.some(openPred)) {
+      openStack.some(openPred)) {
     // Steps of the algorithm:
     // 1. Split list at right most opening bracket.
     // 2. Cut content list at corresponding length.
     // 3. Optimise the neutral fences.
     // 4. Make fenced node.
     //
     // Careful, this reverses openStack!
     var split = cvox.SemanticTree.sliceNodes_(openStack, openPred, true);
     // We know that
     // (a) div & tail exist,
     // (b) all are combined in this step into a single fenced node,
     // (c) head is the new openStack,
     // (d) the new contentStack is remainder of contentStack + new fenced node +
     // shift of content.
     var rightContent = contentStack.pop();
     var cutLength = contentStack.length - split.tail.length + 1;
-    var innerNodes = this.processNeutralFences_(
-        split.tail, contentStack.slice(cutLength));
+    var innerNodes =
+        this.processNeutralFences_(split.tail, contentStack.slice(cutLength));
     contentStack = contentStack.slice(0, cutLength);
     var fenced = this.makeHorizontalFencedNode_(
         split.div, fences.shift(),
         contentStack.pop().concat(innerNodes, rightContent));
     contentStack.push(contentStack.pop().concat([fenced], content.shift()));
     return this.processFences_(fences, content, split.head, contentStack);
   }
   // Final Case: A singular closing fence.
   // We turn the fence into a punctuation.
   var fenced = fences.shift();
@@ skipping 13 matching lines @@
  *     nodes.
  * @private
  */
 cvox.SemanticTree.prototype.processNeutralFences_ = function(fences, content) {
   if (fences.length == 0) {
     return fences;
   }
   if (fences.length == 1) {
     cvox.SemanticTree.fenceToPunct_(fences[0]);
     return fences;
-    }
+  }
   var firstFence = fences.shift();
-  var split = cvox.SemanticTree.sliceNodes_(
-      fences, function(x) {return x.textContent == firstFence.textContent;});
+  var split = cvox.SemanticTree.sliceNodes_(fences, function(x) {
+    return x.textContent == firstFence.textContent;
+  });
   if (!split.div) {
     cvox.SemanticTree.fenceToPunct_(firstFence);
     var restContent = content.shift();
     restContent.unshift(firstFence);
     return restContent.concat(this.processNeutralFences_(fences, content));
   }
-  var newContent = this.combineFencedContent_(
-      firstFence, split.div, split.head, content);
+  var newContent =
+      this.combineFencedContent_(firstFence, split.div, split.head, content);
   if (split.tail.length > 0) {
     var leftContent = newContent.shift();
     var result = this.processNeutralFences_(split.tail, newContent);
     return leftContent.concat(result);
   }
   return newContent[0];
 };
 
 
 /**
@@ skipping 10 matching lines @@
  *     remainder.
  * @return {!Array<!Array<cvox.SemanticTree.Node>>} List of content nodes
  *     where the first is the fully fenced node wrt. the given left and right
  *     fence.
  * @private
  */
 cvox.SemanticTree.prototype.combineFencedContent_ = function(
     leftFence, rightFence, midFences, content) {
 
   if (midFences.length == 0) {
-    var fenced = this.makeHorizontalFencedNode_(
-        leftFence, rightFence, content.shift());
+    var fenced =
+        this.makeHorizontalFencedNode_(leftFence, rightFence, content.shift());
     content.unshift(fenced);
     return content;
   }
 
   var leftContent = content.shift();
   var cutLength = midFences.length - 1;
   var midContent = content.slice(0, cutLength);
   content = content.slice(cutLength);
   var rightContent = content.shift();
   var innerNodes = this.processNeutralFences_(midFences, midContent);
   leftContent.push.apply(leftContent, innerNodes);
   leftContent.push.apply(leftContent, rightContent);
-  var fenced = this.makeHorizontalFencedNode_(
-      leftFence, rightFence, leftContent);
+  var fenced =
+      this.makeHorizontalFencedNode_(leftFence, rightFence, leftContent);
   if (content.length > 0) {
     content[0].unshift(fenced);
   } else {
     content = [[fenced]];
   }
   return content;
- };
+};
 
 
 /**
  * Rewrite fences into punctuation. This is done with any "leftover" fence.
  * @param {cvox.SemanticTree.Node} fence Fence.
  * @private
  */
 cvox.SemanticTree.fenceToPunct_ = function(fence) {
   fence.type = cvox.SemanticAttr.Type.PUNCTUATION;
   switch (fence.role) {
     case cvox.SemanticAttr.Role.NEUTRAL:
-    fence.role = cvox.SemanticAttr.Role.VBAR;
-    break;
+      fence.role = cvox.SemanticAttr.Role.VBAR;
+      break;
     case cvox.SemanticAttr.Role.OPEN:
-    fence.role = cvox.SemanticAttr.Role.OPENFENCE;
-    break;
+      fence.role = cvox.SemanticAttr.Role.OPENFENCE;
+      break;
     case cvox.SemanticAttr.Role.CLOSE:
-    fence.role = cvox.SemanticAttr.Role.CLOSEFENCE;
-    break;
+      fence.role = cvox.SemanticAttr.Role.CLOSEFENCE;
+      break;
   }
 };
 
 
 /**
  * Create a fenced node.
  * @param {cvox.SemanticTree.Node} ofence Opening fence.
  * @param {cvox.SemanticTree.Node} cfence Closing fence.
  * @param {!Array<cvox.SemanticTree.Node>} content The content
  *     between the fences.
@@ skipping 18 matching lines @@
  * Combines sequences of punctuated expressions in a list of nodes.
  * @param {!Array<cvox.SemanticTree.Node>} nodes The list of nodes.
  * @return {!Array<cvox.SemanticTree.Node>} The new list of nodes.
  * @private
  */
 cvox.SemanticTree.prototype.getPunctuationInRow_ = function(nodes) {
   // For now we just make a punctuation node with a particular role. This is
   // similar to an mrow. The only exception are ellipses, which we assume to be
   // in lieu of identifiers.
   // In addition we keep the single punctuation nodes as content.
-  var partition = cvox.SemanticTree.partitionNodes_(
-      nodes, function(x) {
-        return cvox.SemanticTree.attrPred_('type', 'PUNCTUATION')(x) &&
-            !cvox.SemanticTree.attrPred_('role', 'ELLIPSIS')(x);});
+  var partition = cvox.SemanticTree.partitionNodes_(nodes, function(x) {
+    return cvox.SemanticTree.attrPred_('type', 'PUNCTUATION')(x) &&
+        !cvox.SemanticTree.attrPred_('role', 'ELLIPSIS')(x);
+  });
   if (partition.rel.length == 0) {
     return nodes;
   }
   var newNodes = [];
   var firstComp = partition.comp.shift();
   if (firstComp.length > 0) {
     newNodes.push(this.processRow_(firstComp));
   }
   var relCounter = 0;
   while (partition.comp.length > 0) {
@@ skipping 17 matching lines @@
  * @private
  */
 cvox.SemanticTree.prototype.makePunctuatedNode_ = function(
     nodes, punctuations) {
   var newNode = this.makeBranchNode_(
       cvox.SemanticAttr.Type.PUNCTUATED, nodes, punctuations);
 
   if (punctuations.length == 1 &&
       nodes[0].type == cvox.SemanticAttr.Type.PUNCTUATION) {
     newNode.role = cvox.SemanticAttr.Role.STARTPUNCT;
-  } else if (punctuations.length == 1 &&
+  } else if (
+      punctuations.length == 1 &&
       nodes[nodes.length - 1].type == cvox.SemanticAttr.Type.PUNCTUATION) {
     newNode.role = cvox.SemanticAttr.Role.ENDPUNCT;
   } else {
     newNode.role = cvox.SemanticAttr.Role.SEQUENCE;
   }
   return newNode;
 };
 
 
 /**
@@ skipping 13 matching lines @@
       cvox.SemanticTree.attrPred_('type', 'LIMBOTH')(center) ||
       cvox.SemanticTree.attrPred_('type', 'LIMLOWER')(center) ||
       cvox.SemanticTree.attrPred_('type', 'LIMUPPER')(center) ||
       (isFunction && cvox.SemanticTree.attrPred_('role', 'LIMFUNC')(center));
   var type = cvox.SemanticAttr.Type.UNKNOWN;
   // TODO (sorge) Make use of the difference in information on sub vs under etc.
   if (isLimit) {
     switch (mmlTag) {
       case 'MSUB':
       case 'MUNDER':
-      type = cvox.SemanticAttr.Type.LIMLOWER;
-      break;
+        type = cvox.SemanticAttr.Type.LIMLOWER;
+        break;
       case 'MSUP':
       case 'MOVER':
-      type = cvox.SemanticAttr.Type.LIMUPPER;
-      break;
+        type = cvox.SemanticAttr.Type.LIMUPPER;
+        break;
       case 'MSUBSUP':
       case 'MUNDEROVER':
-      type = cvox.SemanticAttr.Type.LIMBOTH;
-      break;
+        type = cvox.SemanticAttr.Type.LIMBOTH;
+        break;
     }
   } else {
     switch (mmlTag) {
       case 'MSUB':
-      type = cvox.SemanticAttr.Type.SUBSCRIPT;
-      break;
+        type = cvox.SemanticAttr.Type.SUBSCRIPT;
+        break;
       case 'MSUP':
-      type = cvox.SemanticAttr.Type.SUPERSCRIPT;
-      break;
+        type = cvox.SemanticAttr.Type.SUPERSCRIPT;
+        break;
       case 'MSUBSUP':
-      var innerNode = this.makeBranchNode_(cvox.SemanticAttr.Type.SUBSCRIPT,
-                                      [center, children[1]], []);
-      innerNode.role = center.role;
-      children = [innerNode, children[2]];
-      type = cvox.SemanticAttr.Type.SUPERSCRIPT;
-      break;
+        var innerNode = this.makeBranchNode_(
+            cvox.SemanticAttr.Type.SUBSCRIPT, [center, children[1]], []);
+        innerNode.role = center.role;
+        children = [innerNode, children[2]];
+        type = cvox.SemanticAttr.Type.SUPERSCRIPT;
+        break;
       case 'MOVER':
-      type = cvox.SemanticAttr.Type.OVERSCORE;
-      break;
+        type = cvox.SemanticAttr.Type.OVERSCORE;
+        break;
       case 'MUNDER':
-      type = cvox.SemanticAttr.Type.UNDERSCORE;
-      break;
+        type = cvox.SemanticAttr.Type.UNDERSCORE;
+        break;
       case 'MUNDEROVER':
       default:
-      var innerNode = this.makeBranchNode_(cvox.SemanticAttr.Type.UNDERSCORE,
-                                      [center, children[1]], []);
-      innerNode.role = center.role;
-      children = [innerNode, children[2]];
-      type = cvox.SemanticAttr.Type.OVERSCORE;
-      break;
+        var innerNode = this.makeBranchNode_(
+            cvox.SemanticAttr.Type.UNDERSCORE, [center, children[1]], []);
+        innerNode.role = center.role;
+        children = [innerNode, children[2]];
+        type = cvox.SemanticAttr.Type.OVERSCORE;
+        break;
     }
   }
   var newNode = this.makeBranchNode_(type, children, []);
   newNode.role = center.role;
   return newNode;
 };
 
 
 /**
  * Recursive method to accumulate function expressions.
@@ skipping 42 matching lines @@
  * @param {!Array<cvox.SemanticTree.Node>} restNodes The remainder list of
  *     nodes. They can useful to look ahead if there is an explicit function
  *     application. If there is one, it will be destructively removed!
  * @return {!string} The string specifying the heuristic.
  * @private
  */
 cvox.SemanticTree.classifyFunction_ = function(funcNode, restNodes) {
   //  We do not allow double function application. This is not lambda calculus!
   if (funcNode.type == cvox.SemanticAttr.Type.APPL ||
       funcNode.type == cvox.SemanticAttr.Type.BIGOP ||
-          funcNode.type == cvox.SemanticAttr.Type.INTEGRAL) {
+      funcNode.type == cvox.SemanticAttr.Type.INTEGRAL) {
     return '';
   }
   // Find and remove explicit function applications.
   // We now treat funcNode as a prefix function, regardless of what its actual
   // content is.
   if (restNodes[0] &&
       restNodes[0].textContent == cvox.SemanticAttr.functionApplication()) {
     // Remove explicit function application. This is destructive on the
     // underlying list.
     restNodes.shift();
     cvox.SemanticTree.propagatePrefixFunc_(funcNode);
     return 'prefix';
   }
   switch (funcNode.role) {
     case cvox.SemanticAttr.Role.INTEGRAL:
-    return 'integral';
-    break;
+      return 'integral';
+      break;
     case cvox.SemanticAttr.Role.SUM:
-    return 'bigop';
-    break;
+      return 'bigop';
+      break;
     case cvox.SemanticAttr.Role.PREFIXFUNC:
     case cvox.SemanticAttr.Role.LIMFUNC:
-    return 'prefix';
-    break;
+      return 'prefix';
+      break;
     default:
-    if (funcNode.type == cvox.SemanticAttr.Type.IDENTIFIER) {
-      return 'simple';
-    }
+      if (funcNode.type == cvox.SemanticAttr.Type.IDENTIFIER) {
+        return 'simple';
+      }
   }
   return '';
 };
 
 
 /**
  * Propagates a prefix function role in a node.
  * @param {cvox.SemanticTree.Node} funcNode The node whose role is to be
  * rewritten.
  * @private
@@ skipping 13 matching lines @@
  * @param {!Array<cvox.SemanticTree.Node>} rest List of nodes to choose
  *     arguments from.
  * @param {string} heuristic The heuristic to follow.
  * @return {!Array<!cvox.SemanticTree.Node>} The function and the remainder of
  *     the rest list.
  * @private
  */
 cvox.SemanticTree.prototype.getFunctionArgs_ = function(func, rest, heuristic) {
   switch (heuristic) {
     case 'integral':
-    var components = this.getIntegralArgs_(rest);
-    var integrand = this.processRow_(components.integrand);
-    var funcNode = this.makeIntegralNode_(func, integrand, components.intvar);
-    components.rest.unshift(funcNode);
-    return components.rest;
-    break;
+      var components = this.getIntegralArgs_(rest);
+      var integrand = this.processRow_(components.integrand);
+      var funcNode = this.makeIntegralNode_(func, integrand, components.intvar);
+      components.rest.unshift(funcNode);
+      return components.rest;
+      break;
     case 'prefix':
-    if (rest[0] && rest[0].type == cvox.SemanticAttr.Type.FENCED) {
-      funcNode = this.makeFunctionNode_(
-          func, /** @type {!cvox.SemanticTree.Node} */ (rest.shift()));
-      rest.unshift(funcNode);
+      if (rest[0] && rest[0].type == cvox.SemanticAttr.Type.FENCED) {
+        funcNode = this.makeFunctionNode_(
+            func, /** @type {!cvox.SemanticTree.Node} */ (rest.shift()));
+        rest.unshift(funcNode);
+        return rest;
+      }
+    case 'bigop':
+      var partition = cvox.SemanticTree.sliceNodes_(
+          rest, cvox.SemanticTree.prefixFunctionBoundary_);
+      var arg = this.processRow_(partition.head);
+      if (heuristic == 'prefix') {
+        funcNode = this.makeFunctionNode_(func, arg);
+      } else {
+        funcNode = this.makeBigOpNode_(func, arg);
+      }
+      if (partition.div) {
+        partition.tail.unshift(partition.div);
+      }
+      partition.tail.unshift(funcNode);
+      return partition.tail;
+      break;
+    case 'simple':
+      if (rest.length == 0) {
+        return [func];
+      }
+      var firstArg = rest[0];
+      if (firstArg.type == cvox.SemanticAttr.Type.FENCED &&
+          firstArg.role != cvox.SemanticAttr.Role.NEUTRAL &&
+          this.simpleFunctionHeuristic_(firstArg)) {
+        funcNode = this.makeFunctionNode_(
+            func, /** @type {!cvox.SemanticTree.Node} */ (rest.shift()));
+        rest.unshift(funcNode);
+        return rest;
+      }
+      rest.unshift(func);
       return rest;
-    }
-    case 'bigop':
-    var partition = cvox.SemanticTree.sliceNodes_(
-        rest, cvox.SemanticTree.prefixFunctionBoundary_);
-    var arg = this.processRow_(partition.head);
-    if (heuristic == 'prefix') {
-      funcNode = this.makeFunctionNode_(func, arg);
-    } else {
-      funcNode = this.makeBigOpNode_(func, arg);
-    }
-    if (partition.div) {
-      partition.tail.unshift(partition.div);
-    }
-    partition.tail.unshift(funcNode);
-    return partition.tail;
-    break;
-    case 'simple':
-    if (rest.length == 0) {
-      return [func];
-    }
-    var firstArg = rest[0];
-    if (firstArg.type == cvox.SemanticAttr.Type.FENCED &&
-        firstArg.role != cvox.SemanticAttr.Role.NEUTRAL &&
-            this.simpleFunctionHeuristic_(firstArg)) {
-      funcNode = this.makeFunctionNode_(
-          func, /** @type {!cvox.SemanticTree.Node} */ (rest.shift()));
-      rest.unshift(funcNode);
-      return rest;
-    }
-    rest.unshift(func);
-    return rest;
-    break;
+      break;
   }
   return [];
 };
 
 
 /**
  * Tail recursive function to obtain integral arguments.
  * @param {!Array<cvox.SemanticTree.Node>} nodes List of nodes to take
  * arguments from.
  * @param {Array<cvox.SemanticTree.Node>=} args List of integral arguments.
@@ skipping 12 matching lines @@
   var firstNode = nodes[0];
   if (cvox.SemanticTree.generalFunctionBoundary_(firstNode)) {
     return {integrand: args, intvar: null, rest: nodes};
   }
   if (cvox.SemanticTree.integralDxBoundarySingle_(firstNode)) {
     return {integrand: args, intvar: firstNode, rest: nodes.slice(1)};
   }
   if (nodes[1] && cvox.SemanticTree.integralDxBoundary_(firstNode, nodes[1])) {
     var comma = this.createNode_();
     comma.updateContent_(cvox.SemanticAttr.invisibleComma());
-    var intvar = this.makePunctuatedNode_(
-        [firstNode, comma, nodes[1]], [comma]);
+    var intvar =
+        this.makePunctuatedNode_([firstNode, comma, nodes[1]], [comma]);
     intvar.role = cvox.SemanticAttr.Role.INTEGRAL;
     return {integrand: args, intvar: intvar, rest: nodes.slice(2)};
   }
   args.push(nodes.shift());
   return this.getIntegralArgs_(nodes, args);
 };
 
 
 /**
  * Create a function node.
  * @param {!cvox.SemanticTree.Node} func The function operator.
  * @param {!cvox.SemanticTree.Node} arg The argument.
  * @return {!cvox.SemanticTree.Node} The new function node.
  * @private
  */
 cvox.SemanticTree.prototype.makeFunctionNode_ = function(func, arg) {
   var applNode = this.createNode_();
   applNode.updateContent_(cvox.SemanticAttr.functionApplication());
   applNode.type = cvox.SemanticAttr.Type.PUNCTUATION;
   applNode.role = cvox.SemanticAttr.Role.APPLICATION;
-  var newNode = this.makeBranchNode_(cvox.SemanticAttr.Type.APPL, [func, arg],
-                                [applNode]);
+  var newNode = this.makeBranchNode_(
+      cvox.SemanticAttr.Type.APPL, [func, arg], [applNode]);
   newNode.role = func.role;
   return newNode;
 };
 
 
 /**
  * Create a big operator node.
  * @param {!cvox.SemanticTree.Node} bigOp The big operator.
  * @param {!cvox.SemanticTree.Node} arg The argument.
  * @return {!cvox.SemanticTree.Node} The new big operator node.
  * @private
  */
 cvox.SemanticTree.prototype.makeBigOpNode_ = function(bigOp, arg) {
-  var newNode = this.makeBranchNode_(
-      cvox.SemanticAttr.Type.BIGOP, [bigOp, arg], []);
+  var newNode =
+      this.makeBranchNode_(cvox.SemanticAttr.Type.BIGOP, [bigOp, arg], []);
   newNode.role = bigOp.role;
   return newNode;
 };
 
 
 /**
  * Create an integral node. It has three children: integral, integrand and
  * integration variable. The latter two can be omitted.
  * @param {!cvox.SemanticTree.Node} integral The integral operator.
  * @param {cvox.SemanticTree.Node} integrand The integrand.
  * @param {cvox.SemanticTree.Node} intvar The integral variable.
  * @return {!cvox.SemanticTree.Node} The new integral node.
  * @private
  */
 cvox.SemanticTree.prototype.makeIntegralNode_ = function(
     integral, integrand, intvar) {
   integrand = integrand || this.makeEmptyNode_();
   intvar = intvar || this.makeEmptyNode_();
-  var newNode = this.makeBranchNode_(cvox.SemanticAttr.Type.INTEGRAL,
-                                [integral, integrand, intvar], []);
+  var newNode = this.makeBranchNode_(
+      cvox.SemanticAttr.Type.INTEGRAL, [integral, integrand, intvar], []);
   newNode.role = integral.role;
   return newNode;
 };
 
 
 /**
  * Predicate implementing the boundary criteria for simple functions:
  *
  * @param {!cvox.SemanticTree.Node} node A semantic node of type fenced.
  * @return {boolean} True if the node meets the boundary criteria.
@@ skipping 37 matching lines @@
 
 
 /**
  * Predicate implementing the boundary criteria for integrals dx on two nodes.
  * @param {cvox.SemanticTree.Node} firstNode A semantic node.
  * @param {cvox.SemanticTree.Node} secondNode The direct neighbour of first
  *     Node.
  * @return {boolean} True if the second node exists and the first node is a 'd'.
  * @private
  */
-cvox.SemanticTree.integralDxBoundary_ = function(
-    firstNode, secondNode) {
+cvox.SemanticTree.integralDxBoundary_ = function(firstNode, secondNode) {
   return !!secondNode &&
       cvox.SemanticTree.attrPred_('type', 'IDENTIFIER')(secondNode) &&
-          cvox.SemanticAttr.isCharacterD(firstNode.textContent);
+      cvox.SemanticAttr.isCharacterD(firstNode.textContent);
 };
 
 
 /**
  * Predicate implementing the boundary criteria for integrals dx on a single
  * node.
  * @param {cvox.SemanticTree.Node} node A semantic node.
  * @return {boolean} True if the node meets the boundary criteria.
  * @private
  */
@@ skipping 54 matching lines @@
 };
 
 
 /**
  * Decides if a node is a table or multiline element.
  * @param {cvox.SemanticTree.Node} node A node.
  * @return {boolean} True if node is either table or multiline.
  * @private
  */
 cvox.SemanticTree.isTableOrMultiline_ = function(node) {
-  return !!node && (cvox.SemanticTree.attrPred_('type', 'TABLE')(node) ||
-      cvox.SemanticTree.attrPred_('type', 'MULTILINE')(node));
+  return !!node &&
+      (cvox.SemanticTree.attrPred_('type', 'TABLE')(node) ||
+       cvox.SemanticTree.attrPred_('type', 'MULTILINE')(node));
 };
 
 
 /**
  * Heuristic to decide if we have a matrix: An expression fenced on both sides
  * without any other content is considered a fenced node.
  * @param {cvox.SemanticTree.Node} node A node.
  * @return {boolean} True if we believe we have a matrix.
  * @private
  */
 cvox.SemanticTree.tableIsMatrixOrVector_ = function(node) {
   return !!node && cvox.SemanticTree.attrPred_('type', 'FENCED')(node) &&
       cvox.SemanticTree.attrPred_('role', 'LEFTRIGHT')(node) &&
-          node.childNodes.length == 1 &&
-              cvox.SemanticTree.isTableOrMultiline_(node.childNodes[0]);
+      node.childNodes.length == 1 &&
+      cvox.SemanticTree.isTableOrMultiline_(node.childNodes[0]);
 };
 
 
 /**
  * Replaces a fenced node by a matrix or vector node.
  * @param {!cvox.SemanticTree.Node} node The fenced node to be rewritten.
  * @return {!cvox.SemanticTree.Node} The matrix or vector node.
  * @private
  */
 cvox.SemanticTree.prototype.tableToMatrixOrVector_ = function(node) {
   var matrix = node.childNodes[0];
   var type = cvox.SemanticTree.attrPred_('type', 'MULTILINE')(matrix) ?
-      'VECTOR' : 'MATRIX';
+      'VECTOR' :
+      'MATRIX';
   matrix.type = cvox.SemanticAttr.Type[type];
   node.contentNodes.forEach(goog.bind(matrix.appendContentNode_, matrix));
   for (var i = 0, row; row = matrix.childNodes[i]; i++) {
     cvox.SemanticTree.assignRoleToRow_(row, cvox.SemanticAttr.Role[type]);
   }
   return matrix;
 };
 
 
 /**
  * Heuristic to decide if we have a case statement: An expression with a
  * singular open fence before it.
  * @param {!cvox.SemanticTree.Node} table A table node.
  * @param {!Array<cvox.SemanticTree.Node>} prevNodes A list of previous nodes.
  * @return {boolean} True if we believe we have a case statement.
  * @private
  */
 cvox.SemanticTree.tableIsCases_ = function(table, prevNodes) {
   return prevNodes.length > 0 &&
-      cvox.SemanticTree.attrPred_('role', 'OPENFENCE')(
-          prevNodes[prevNodes.length - 1]);
+      cvox.SemanticTree.attrPred_(
+          'role', 'OPENFENCE')(prevNodes[prevNodes.length - 1]);
 };
 
 
 /**
  * Makes case node out of a table and a fence.
  * @param {!cvox.SemanticTree.Node} table The table containing the cases.
  * @param {!cvox.SemanticTree.Node} openFence The left delimiter of the case
  *     statement.
  * @return {!cvox.SemanticTree.Node} The cases node.
  * @private
@@ skipping 15 matching lines @@
 // similarities in columns (e.g., single relation symbols, like equalities or
 // inequalities in the same column could indicate an equation array).
 /**
  * Heuristic to decide if we have a multiline formula. A table is considered a
  * multiline formula if it does not have any separate cells.
  * @param {!cvox.SemanticTree.Node} table A table node.
  * @return {boolean} True if we believe we have a mulitline formula.
  * @private
  */
 cvox.SemanticTree.tableIsMultiline_ = function(table) {
-  return table.childNodes.every(
-      function(row) {
-        var length = row.childNodes.length;
-        return length <= 1;});
+  return table.childNodes.every(function(row) {
+    var length = row.childNodes.length;
+    return length <= 1;
+  });
 };
 
 
 /**
  * Rewrites a table to multiline structure, simplifying it by getting rid of the
  * cell hierarchy level.
  * @param {!cvox.SemanticTree.Node} table The node to be rewritten a multiline.
  * @private
  */
 cvox.SemanticTree.prototype.tableToMultiline_ = function(table) {
   table.type = cvox.SemanticAttr.Type.MULTILINE;
   for (var i = 0, row; row = table.childNodes[i]; i++) {
     cvox.SemanticTree.rowToLine_(row, cvox.SemanticAttr.Role.MULTILINE);
   }
 };
 
 
 /**
  * Converts a row that only contains one cell into a single line.
  * @param {!cvox.SemanticTree.Node} row The row to convert.
  * @param {cvox.SemanticAttr.Role=} role The new role for the line.
  * @private
  */
 cvox.SemanticTree.rowToLine_ = function(row, role) {
   role = role || cvox.SemanticAttr.Role.UNKNOWN;
   if (cvox.SemanticTree.attrPred_('type', 'ROW')(row) &&
       row.childNodes.length == 1 &&
-          cvox.SemanticTree.attrPred_('type', 'CELL')(row.childNodes[0])) {
+      cvox.SemanticTree.attrPred_('type', 'CELL')(row.childNodes[0])) {
     row.type = cvox.SemanticAttr.Type.LINE;
     row.role = role;
     row.childNodes = row.childNodes[0].childNodes;
   }
 };
 
 
 /**
  * Assign a row and its contained cells a new role value.
  * @param {!cvox.SemanticTree.Node} row The row to be updated.
@@ skipping 29 matching lines @@
  * @private
  */
 cvox.SemanticTree.sliceNodes_ = function(nodes, pred, reverse) {
   if (reverse) {
     nodes.reverse();
   }
   var head = [];
   for (var i = 0, node; node = nodes[i]; i++) {
     if (pred(node)) {
       if (reverse) {
-        return {head: nodes.slice(i + 1).reverse(),
-                div: node,
-                tail: head.reverse()};
+        return {
+          head: nodes.slice(i + 1).reverse(),
+          div: node,
+          tail: head.reverse()
+        };
       }
-      return {head: head,
-              div: node,
-              tail: nodes.slice(i + 1)};
+      return {head: head, div: node, tail: nodes.slice(i + 1)};
     }
     head.push(node);
   }
   if (reverse) {
     return {head: [], div: null, tail: head.reverse()};
   }
   return {head: head, div: null, tail: []};
 };
 
 
@@ skipping 33 matching lines @@
  * Constructs a predicate to check the semantic attribute of a node.
  * @param {!string} prop The property of a node.
  * @param {!string} attr The attribute.
  * @return {function(cvox.SemanticTree.Node): boolean} The predicate.
  * @private
  */
 
 cvox.SemanticTree.attrPred_ = function(prop, attr) {
   var getAttr = function(prop) {
     switch (prop) {
-      case 'type': return cvox.SemanticAttr.Type[attr];
-      case 'role': return cvox.SemanticAttr.Role[attr];
-      case 'font': return cvox.SemanticAttr.Font[attr];
+      case 'type':
+        return cvox.SemanticAttr.Type[attr];
+      case 'role':
+        return cvox.SemanticAttr.Role[attr];
+      case 'font':
+        return cvox.SemanticAttr.Font[attr];
     }
   };
 
-  return function(node) {return node[prop] == getAttr(prop);};
+  return function(node) {
+    return node[prop] == getAttr(prop);
+  };
 };