anchor.diff:  commands can be registred to be executed when certain events arise.
   to register a hook, use the hook command.
   
  -:hook <scope> <hook_name> <filtering_regex> <command> <command_args>...
  +:hook <scope> <hook_name> <filtering_regex> <commands>
   
   <scope> can be either global, buffer or window, the scope are hierarchical,
   meaning that a Window calling a hook will execute it's own, the buffer ones
   and the global ones.
   
  +<command> is a string containing the commands to execute when the hook is
  +called.
  +
   for example, to automatically use line numbering with .cc files,
   use the following command:
   
  -:hook global WinCreate .*\.cc addhl number_lines
  -
  -Shell expension
  +:hook global WinCreate .*\.cc %{ addhl number_lines }
  +
  +Shell expansion
   ---------------
   
  -Commands support the shell backtick syntax, and kakoune internal state
  -can be accessed through environment variable. For example, if you are
  -editing the editor.cc file, typing ':edit `echo ${kak_bufname/%.cc/.hh}`'
  -will edit the editor.hh file.
  -
  +A special string syntax is supported which replace it's content with the
  +output of the shell commands in it, it is similar to the shell $(...)
  +syntax and is evaluated only when needed.
  +for example: %sh{ ls } is replaced with the output of the ls command.
  +
  +Some of kakoune state is available through environment variables:
  +
  + * *kak_selection*: content of the last selection
  + * *kak_bufname*: name of the current buffer
  + * *kak_opt_name*: value of option name
  + * *kak_reg_x*: value of register x
  +
  +for example you can print informations on the current file in the status
  +line using:
  +:echo %sh{ ls -l $kak_bufname }
  +
  +Defining Commands
  +-----------------
  +
  +new commands can be defined using the *def* command.
  +
  +:def <command_name> <commands>
  +
  +<commands> is a string containing the commands to execute
  +
  +def can also takes some flags:
  + * *-env-params*: pass parameters given to commands in the environement as
  +                  kak_paramN with N the parameter number
  + * *-shell-completion*: following string is a shell command which takes
  +                        parameters through the environemnt and output one
  +                        completion candidate per line.
  + * *-allow-override*: allow the new command to replace an exisiting one
  +                      with the same name.
  +
  +Using shell expansion permits to define complex commands or to access
  +kakoune state:
  +
  +:def print_selection %{ echo %sh{ ${kak_selection} } }
  +
  +Some helper commands can be used to define composite commands:
  +
  + * menu <label1> <commands1> <label2> <commands2>...: display a menu using
  +     labels, the selected label's commands are executed.
  + * try <commands> catch <on_error_commands>: prevent an error in <commands>
  +     from aborting the whole commands execution, execute <on_error_commands>
  +     instead.
  +
  +Note that these commands are available in interactive command mode, but are
  +not that useful in this context.
  
positive.code: 
  exisiting filters are:
  
  * *preserve_indent*: insert previous line indent when inserting a newline
  * *cleanup_whitespaces*: remove trailing whitespaces on the previous line
                           when inserting an end-of-line.
  * *expand_tabulations*: insert spaces instead of tab characters
  
  Hooks
  -----
  
negative.code: Using alt-i and alt-a, you can select some text object, the starting
  point is always the last character of the selection.
  
   * _b_, _(_ or _)_: select the enclosing parenthesis
   * _B_, _{_ or _}_: select the enclosing {} block
   * _[_ or _]_: select the enclosing [] block
   * _<_ or _>_: select the enclosing <> block
   * w: select the whole word
   * W: select the whole WORD
  
  When it makes sense, _alt-i_ selects the inner object and alt-a the whole
  object. For example _alt-i_ ( will only select the inside of the parenthesis,
  