anchor.diff:  val render = renderAnonymous orElse renderAuthorized
   -----------------------------------
   
  -Event with access gives you literally access to information from the client side. In this case it is a values of the input fields.
  +Event with access gives you literally access to information from the client side. In this case, it is a value of the input fields.
   
   Event handlers should return `EventResult`.
   
   EventResult
   ~~~~~~~~~~~
   
  -Korolev expects `EventResult` as return-type of event handlers. There are three type of event results.
  -
  -1. `immediateTransition` - Is a transition which be applied to current state right now. It's useful to making lightweight synchronous transitions. For example you have a page with the "Query" field and the "Search" button. When the button was clicked, your application requests database or micro-service to execute the query. But user want to see reaction be before you receive the data. So you update the state with "Loading" flag in `immediateTransition` and user see reaction immediately. Signature of `immediateTransition` is `Transition[S]` which are type alias to `PartialFunction[S, S]` where `S` is your state type.
  -
  -2. `deferredTransition` - In previous example your application does request to some sort of backend. Such request in Scala usually is asynchronous. So `deferredTransition` is a way to make your application await for response. `deferredTransition` will be applied to the state when the `Future` will be completed. Signature of `deferredTransition` is `Future[Transition[S]]`.
  +Korolev expects `EventResult` as a return type of event handlers. There are three types of event results.
  +
  +
  +1. `immediateTransition` - Is a transition which is applied to current state right now. It's useful to making lightweight synchronous transitions. For example, you have a page with the "Query" field and the "Search" button. When the button was clicked, your application requests database or micro-service to execute the query. But user wants to see reaction be before you receive the data. So you update the state with "Loading" flag in `immediateTransition` and user see reaction immediately. Signature of `immediateTransition` is `Transition[S]` which are type alias to `PartialFunction[S, S]` where `S` is your state type.
  +
  +2. `deferredTransition` - In the previous example, your application does request to some sort of backend. Such request in Scala usually is asynchronous. So `deferredTransition` is a way to make your application waits for the response. `deferredTransition` will be applied to the state when the `Future` will be completed. Signature of `deferredTransition` is `Future[Transition[S]]`.
   
   3. `noTransition` - It means you don't want to make any reaction.
   
  -Also you can combine `immediateTransition` and `deferredTransition`.
  +Also, you can combine `immediateTransition` and `deferredTransition`.
   
   Access element properties
   ~~~~~~~~~~~~~~~~~~~~~~~~~
   
  -In the scope of event you can access to the element properties if element was bound with `elementId`. You can get value (limited by simple types like `String` and `Double`).
  +In the scope of event, you can access the element properties if an element was bound with `elementId`. You can get value (limited by simple types like `String` and `Double`).
   
   [source,scala]
   -----------------------------------
  
positive.code: 
  Routing
  ~~~~~~~
  (TODO)
  
  Design patterns
  ---------------
  
negative.code: Device and Session
  ~~~~~~~~~~~~~~~~~~
  
  When a user opens your application first time, Korolev sets a cookie named `device` with the unique identifier. After that, you can identify the user by deviceId. Note that every new browser will receive a new `deviceId`.
  
  A session is created when the user opens a page. Every session has the unique identifier. Korolev creates a State for every session.
  
  State
  ~~~~~
  