 
   unwrapAll: ->
     node = this
-    continue until node is node .= unwrap()
+    continue until node is node.=unwrap()
     node
 
   # Default implementations of the common node properties and methods. Nodes
   # will override these with custom logic, if needed.
   children: []
 
+  isComplex       : YES
   isStatement     : NO
   isPureStatement : NO
-  isComplex       : YES
-  isChainable     : NO
   isAssignable    : NO
   isArray         : NO
   isObject        : NO
 
   assigns      : NO   # Is this node used to assign a certain variable?
-  unwrap       : THIS
   unfoldSoak   : NO
   unfoldAssign : NO
+  unwrap       : THIS
 
   # `toString` representation of the node, for inspecting the parse tree.
   # This is what `coco --nodes` prints out.


  # Compile a unary **Op**.
  compileUnary: (o) ->
    parts = [op = @op]
    parts.push ' ' if op of <[ new typeof delete void ]> or
                      op of <[ + - ]> and @first.op is op
    parts.push @first.compile o, LEVEL_OP
    parts.reverse() if @flip
    code = parts.join ''
    if o.level <= LEVEL_OP then code else "(#{code})"

  compileMultiIO: (o) ->

        call.newInstance()
        return first
      first = Parens first, true if first instanceof Code and first.bound
    this import {op, first, second, post}

  # Map of comparison operators which are both invertible and chainable.
  COMPARERS = '===':'!==', '==':'!=', '>':'<=', '<':'>='
  COMPARERS[val] = key for all key, val in COMPARERS

  children: <[ first second ]>

  invert: ->
    if op = COMPARERS[@op]
      @op = op
      this
    else if @second
