code: function flattenSupportedOperation(node, parentOp) {
    // First get the list of operands that this operator operates on.
    // e.g. 2 + 3 + 4 + 5 is stored as (((2 + 3) + 4) + 5) in the tree and we
    // want to get the list [2, 3, 4, 5]
    const operands = getOperands(node, parentOp);
  
    // If there's only one operand (possible if 2*x was flattened to 2x)
    // then it's no longer an operation, so we should replace the node
    // with the one operand.
    if (operands.length === 1) {
      node = operands[0];
    }
    else {
      // When we are dealing with flattening division, and there's also
      // multiplication involved, we might end up with a top level * instead.
      // e.g. 2*4/5 is parsed with / at the top, but in the end we want 2 * (4/5)
      // Check for this by first checking if we have more than two operands
      // (which is impossible for division), then by recursing through the
      // original tree for any multiplication node - if there was one, it would
      // have ended up at the root.
      if (node.op === '/' && (operands.length > 2 ||
                              hasMultiplicationBesideDivision(node))) {
        node = Node.Creator.operator('*', operands);
      }
      // similarily, - will become + always
      else if (node.op === '-') {
        node = Node.Creator.operator('+', operands);
      }
      // otherwise keep the operator, replace operands
      else {
        node.args = operands;
      }
      // When we collect operands to flatten multiplication, the
      // multiplication of those operands should never be implicit
      if (node.op === '*') {
        node.implicit = false;
      }
    }
    return node;
  }
docs: Flattens operations (see flattenOperands docstring) for an operator node with an operation type that can be flattened. Currently * + / are supported. Returns the updated, flattened node. NOTE: the returned node will be of operation type `parentOp`, regardless of the operation type of `node`, unless `node` wasn't changed e.g. 2 * 3 / 4 would be * of 2 and 3/4, but 2/3 would stay 2/3 and division