Don't wrap eaches in an empty function call node

Because I was assuming that every expression
started with a literal, calls to `each` were
getting wrapped by a functionCall node with no
functionName, which was subsequently ignored by
the compiler. This removes all of that uselessness

src/compiler.js

         )
         const compiler = new Compiler(node.subtree, this.context)
         const content = compiler.compile()
-
-        if (node.functionName) {
-          this.result += `<${node.functionName}${
-            attributes.length ? ' ' : ''
-          }${attributes.join(' ')}>${content}</${node.functionName}>`
-        } else {
-          this.result += content
-        }
+        this.result += `<${node.functionName}${
+          attributes.length ? ' ' : ''
+        }${attributes.join(' ')}>${content}</${node.functionName}>`
       } else if (node.type === 'string') {
         this.result += node.content
       } else if (node.type === 'identifier') {

src/parser.js

   expr() {
     this.tokenStream.eat(tokenTypes.OPAREN)
 
-    let elementNode = new Node()
-    elementNode.type = 'functionCall'
-    elementNode.functionName = this.tokenStream.eat(tokenTypes.LITERAL).value
-    elementNode.args = []
-    elementNode.subtree = []
+    let node = new Node()
+
+    if (this.tokenStream.peek().type === tokenTypes.LITERAL) {
+      node.type = 'functionCall'
+      node.functionName = this.tokenStream.eat(tokenTypes.LITERAL).value
+    }
+
+    node.args = []
+    node.subtree = []
 
     while (
       this.tokenStream.peek().type != tokenTypes.CPAREN &&
       this.tokenStream.peek().type !== tokenTypes.EOF
     ) {
       if (this.tokenStream.peek().type === tokenTypes.ATTRIBUTE) {
-        elementNode.args.push(this.attribute())
+        node.args.push(this.attribute())
       } else if (this.tokenStream.peek().type === tokenTypes.OPAREN) {
-        elementNode.subtree.push(this.expr())
+        node.subtree.push(this.expr())
       } else if (this.tokenStream.peek().type === tokenTypes.LITERAL) {
-        elementNode.subtree.push(this.identifier())
+        node.subtree.push(this.identifier())
       } else if (this.tokenStream.peek().type === tokenTypes.QUOTE) {
-        elementNode.subtree.push(this.quotedString())
+        node.subtree.push(this.quotedString())
       } else if (this.tokenStream.peek().type === tokenTypes.KEYWORD) {
-        elementNode.subtree.push(this.keyword())
+        node = this.keyword()
       }
     }
 
     this.tokenStream.eat(tokenTypes.CPAREN)
 
-    return elementNode
+    return node
   }
 
   attribute() {