assets/css/index.css

@@ -405,23 +405,14 @@ label input {
   width: 100%;
 }
 
-.tree p {
-    margin-bottom: 0px;
-}
-.tree {
-  padding: 10px;
+.tree, .tree ul {
   position: relative;
+  padding-left: 0;
   list-style-type: none;
   line-height: var(--line-height);
-  background: var(--background-color-alt);
 }
 .tree ul {
   margin: 0;
-  padding: 0;
-  position: relative;
-  list-style-type: none;
-  line-height: var(--line-height);
-  background: var(--background-color-alt);
 }
 .tree ul li {
   position: relative;

assets/css/webfont.css

@@ -49,9 +49,3 @@
 .nf-fa-clipboard_list:before {
   content: "\ed7b";
 }
-.nf-fa-grip_vertical:before {
-  content: "\f142";
-}
-.nf-oct-kebab_horizontal:before {
-  content: "\uf4eb";
-}

content/docs/architecture.smd

@@ -116,7 +116,7 @@ feedback via `logview`.  To view logs use `f11` to toggle the
 previous messages, or alternatively, open flow with the option
 `--show-logs`.
 
-To log something, first, `import log`
+To log something, first import
 
 ```zig
 const log = @import("log");

content/docs/architecture/command.smd

@@ -99,6 +99,24 @@ sent to commands vary for each command.
 Sometimes [keybinding](/docs/architecture/keybind) is enough to
 accomplish a compound of already present commands.
 
+[]($section.id('deepen'))
+## Code organization
+
+Is common to define private functions in a given module that are
+invoked from commands, as usual, functions are meant to be reused and
+help organize code.
+
+For example, in hx mode `helix.zig` the `select_to_char_left_helix`
+command uses the functions `helix_with_selections_const_arg` which
+iterates over all cursels and applies the
+`select_cursel_to_char_left_helix` function.
+
+```zig
+pub fn select_to_char_left_helix(_: *void, ctx: Ctx) Result {
+    try helix_with_selections_const_arg(ctx, &select_cursel_to_char_left_helix);
+}
+```
+
 []($section.id('command_arguments'))
 ### Sending parameters to commands
 
@@ -115,6 +133,7 @@ extract from the context like this:
 
 ```zig
 pub fn goto_line(self: *Self, ctx: Context) Result {
+
     var line: usize = 0;
     if (!try ctx.args.match(.{tp.extract(&line)}))
         return error.InvalidGotoLineArgument;
@@ -143,39 +162,15 @@ and json, packing all of them in Command.Context.
 
 A deeper explanation of the rules about parameter passing is exposed in
 [inner data exchange](/docs/architecture/inner_data_exchange), given
-that parameters can be sent not only to commands, but other broader
+that parameters can be sent not only to commands, but other broather
 use cases.
 
-[]($section.id('deepen'))
-## Code organization
-
-Is common to define private functions in a given module meant to be
-invoked from commands. As usual, reusing code with functions
-help organize code.
-
-For example, in hx mode `src/tui/mode/helix.zig` the
-`select_to_char_left_helix` command uses the functions
-`helix_with_selections_const_arg` which iterates over all cursels and
-applies the `select_cursel_to_char_left_helix` function.
-
-```zig
-pub fn select_to_char_left_helix(_: *void, ctx: Ctx) Result {
-    try helix_with_selections_const_arg(ctx, &select_cursel_to_char_left_helix);
-}
-```
-
 []($section.id('next'))
 ## Next steps
 
-[Minimodes](/docs/architecture/minimode) pass arguments to the editor,
-if you wonder how to go beyond the current buffer window, when there
-are actions like going to a specific line or when searching or
-replacing a character,this is the place.
-
-[Palettes](/docs/architecture/palette) are built to open files, change
-buffers and also pass parameters to commands. Diving out from the
-buffer and editor.
-
+* [minimode](/docs/architecture/minimode) shows argument passing to
+commands in reaction to keypresses.
+* [Palettes](/docs/architecture/palette) invoke commands and pass
+parameters to them.
 * [Add tests](/docs/testing) to harden your code
-* [Sending parameters across](/docs/architecture/inner_data_exchange)
 * [Back to architecture](/docs/architecture)

content/docs/architecture/keybind.smd

@@ -39,7 +39,7 @@ key/combos and add an array, where the first element is the combination
 to map to the commands that will be invoked, the array accepts strings
 like in
 
-```zig
+```js
 ["ctrl+alt+shift+p", "open_command_palette"]
 ```
 
@@ -80,59 +80,27 @@ Some terminology
 
 In general a keybinding json shows this hierarchy:
 
->[]($block.attrs('tree'))
->`flow.json` `<-- keybindings for flow mode`
->`{`
->* "project": {   `<-- imode`
->    * "press": [ `<-- react when press`
->      * ["ctrl+alt+shift+r", "restart"], `<-- the keys with commands`
->      * 
->    * ]
->* },
->* "normal": [    `<-- imode`
->    * "inherit": "project" `<-- Inherits all the keypresses and reactions from project`
->    * "press": [ `<- custom actions for normal imode`
->      * ["ctrl+z", "undo"],
->      * 
->    * ],
->    * "release": [ `<-- normal imode also reacts when some keys are released`
->      * ["left_control", "disable_jump_mode"], `<-- no more jumping when left control is released`
->    * ]
->* ],
->* "select": {  "cursor":"block"  }, `<-- imode with a cursor change`
->* "home": {   "on_match_failure": "ignore"   }, `<-- imode`
->* "overlay/palette": {   } `<-- keys are handled by a palette`
->* "mini/numeric": {   } `<-- minimodes also handle actions`
->*  `}`
+```
+Mode > Imode > press > Key and commands
+map  > map   > array > array(array(string,numbers),strings,numbers)
+```
 
+`Mode` is the json file that holds a map, where each entry has a map
+called `press` that is an array of arrays.
 
-`project` is the main imode in `flow.json`, mapping many combo key down
-presses.
-
-Notice that `normal` imode `inherits` from `project`, meaning all the
-key presses handled by project react the same way in normal, which also
-extends with other keypresses. `normal` also captures key
-releases, we show a sample when the control key is released,
-stopping jumping mode inside flow.json.
-
-`SELECT` imode inherits from normal and shows a different cursor to
-remind it is the current one.
-
-`home` mode is shown when no buffer is open and if the user presses
-keys that are not explicitly handled to bring mental peace to the
-user.
-
-`overlay/palette` gets active when a
-[palette](/docs/architecture) is active.
+`project` is the main imode in `flow.json` and it can be noticed that
+`normal` imode `inherits` from `project`, some modes have `release`,
+usually one will be using only `press` inside `normal` imode or the
+specific mode if inside `vim`, `helix` or `emacs` modes.
 
 Looking further, it can be seen that
 [minimodes](/docs/architecture/minimode) have their own keybinding
-mappings defined in a particular imode, the same as palettes.
+mappings defined in a particular imode.
 
 As stated previously, there is a mode hierarchy, the main mode is flow
-and other modes inherit from it. Each mode inherits, extends and
-overrides actions and define their internal imodes extending as
-required each minimode.
+and other modes inherit from it. We remind that also imodes have a
+hierarchy and it's common for major imodes to be descendants from
+`project`.
 
 []($section.id('adding'))
 ## Adding a Keybinding
@@ -154,7 +122,7 @@ its results to a *scratch buffer* called `test`.
 
 The original definition is:
 
-```zig
+```js
 ["f5", ["create_scratch_buffer", "*test*"], ["shell_execute_insert", "zig", "build", "test"]],
 ```
 
@@ -166,12 +134,12 @@ the `f5` key.
 `create_scratchbuffer` is invoked receiving the parameter `*test*`
 which results in creating a scratch buffer if didn't exist. And then
 executing the command `shell_execute_insert` that receives the
-parameters `zig`, `build`, `test`. This latter command is executing
+paramaters `zig`, `build`, `test`. This latter command is executing
 a shell command called `zig` with the parameters `build` and `test`;
 if you don't have zig installed, it will not work, and you might
 want to remap `f5` to a different shell command.
 
-```zig
+```
 [
   "f5",
   [
@@ -206,7 +174,6 @@ flow.
 
 
 * Making flow even better with [tests](/docs/testing)
-* Adding [new commands](/docs/architecture/command)
-* [Contributing](/docs/contributing)
-* [Getting in touch](https://discord.com/invite/4wvteUPphx) to share
-your combos
+* [How to contribute](/docs/contributing)
+* [Get in touch](https://discord.com/invite/4wvteUPphx) to share your
+combos

content/docs/architecture/minimode.smd

@@ -10,11 +10,12 @@
 },
 ---
 
-Minimodes add functionality to the editor, are opened for short periods
-of time and have their own set of keybindings to execute an specific
-action, i.e. find something in the current buffer or in project files,
-open/save a file, and, in modal modes(like vim and helix), as receiving
-a number as a prefix to repeat an action many times.
+Minimodes commitment is to add functionality to the editor, are opened
+for short periods of time and have their own set of keybindings to
+execute an specific action, i.e. find something in the current buffer
+or in project files, open/save a file, and, in modal modes(like vim
+and helix), as receiving a number as a prefix to repeat an action many
+times.
 
 []($section.id("anatomy"))
 ## Anatomy of minimodes
@@ -110,7 +111,6 @@ example(look for it in the command palette `:`).
 []($section.id("next"))
 ## Next steps
 
-* Create [palettes](/docs/architecture/palette)
+* Head to [architecture](/docs/architecture)
 * Review [commands](/docs/architecture/command)
-* Adjust [keybindings](/docs/architecture/keybind)
-* To [architecture](/docs/architecture)
+* Review [keybindings](/docs/architecture/keybind)

content/docs/architecture/palette.smd

@@ -18,9 +18,9 @@ the elements, and having special elements that trigger different
 actions, for example, the task palette.
 
 Examples of palettes are `command_palette`, `clipboard_palette`, they
-all are based on `src/tui/mode/overlay/palette.zig` doing all the heavy
-lifting and sets the framework to create new palettes as simple as
-possible.
+all are based on `src/tui/mode/overlay/palette.zig that does all the
+heavy lifting and sets the framework to create new palettes as simple
+as possible.
 
 Palettes are an special case of [minimode] and for instance a mode, they
 receive inputs from the keyboard and execute the beforehand mentioned

content/docs/mode/helix.smd

@@ -10,7 +10,7 @@
 },
 ---
 
-This document describes Helix Mode implementation.
+This document describes implementation of Helix Mode.
 
 []($section.id('what'))
 ## What and what not
@@ -19,21 +19,16 @@ The first and biggest difference is that Flow has a mode that emulates
 Helix, or at least has equivalent of the worthiest actions that can be
 done with Helix. The conversely is not true.
 
-When entering to Helix Mode through `F4`, you land on `NOR`
-[imode](/docs/architecture/keybind#hierarchy), there are `SEL` and
-`INS` imodes implemented.
-
 `:` opens up Flow's rich command palette that might have
 functionalities Helix users are used to have, if you find something
 missing, it's possible to
-[open a feature request](https://github.com/neurocyte/flow/issues),
+[open a Feature Request](https://github.com/neurocyte/flow/issues),
 make sure to review
 [other issues](https://github.com/neurocyte/flow/issues?q=is%3Aissue%20state%3Aopen%20label%3Ahelix-mode)
-to avoid repeating or see in [Discord](https://discord.gg/kzJC9fA7)
-to ask if there is a workaround, or anyone else is interested in
-porting your requirement, adding a reaction to an issue offers
-awareness on what to implement or to get higher priority, remember that
-it's possible to bounce back to Flow(f4) mode if needed.
+to avoid repeating or see if there is anyone interested in porting on
+[Discord](https://discord.gg/kzJC9fA7) to ask if or there is a
+workaround, remember that it's possible to bounce back to Flow mode
+if needed.
 
 []($section.id('enhancing'))
 ## Enhancing hx mode
@@ -41,31 +36,29 @@ it's possible to bounce back to Flow(f4) mode if needed.
 This is a programmer's editor, you are more than welcome to enhance to
 suit your needs that maybe coincide with others.
 
-Take a look at [architecture](/docs/architecture) and
+Please take a look at [architecture](/docs/architecture) and
 [contributing](/docs/contributing) for an overview and the mechanics
-of getting your changes into flow.
+of getting your changes into Flow.
 
 hx mode is modal kind, the same as vim mode, and the file that has the
-particular work to make it real is `src/tui/mode/helix.zig`, adding
+particular work to make it real is in `src/tui/mode/helix.zig`, adding
 a `command` and the corresponding `meta` is what is required.
 [More on commands](/docs/architecture/command).
 
 []($section.id('pickers'))
 ### Pickers
 
-Flow hx mode offers most of the Helix pickers functionalities with
-`panels` and [palettes](/docs/architecture/palette).  Example of panels
-are the `g` `r` (go to reference from lsp) and `space` `/` (a.k.a find
-in files). Examples of `palettes` are `space` `b` to pick a buffer or
+Flow hx mode offers most of the picker types equivalents with `panels`
+and [palettes](/docs/architecture/palette).  Example of panels are
+the `g` `r` (go to reference from lsp) and `space` `/` (a.k.a find in
+files). Examples of `palettes` are `space` `b` to pick a buffer or
 `space` `f` to open a file in your project. Panels open below the
 editor while palettes open overlapping the working area.
 
-One medium sized project is to create a **Helix picker** widget that
-has one input widget with two panels, on the left, the list of options
-and, on the right, the preview of the selected option. The input
-widget reacts to various keybindings to manipulate the objects inside
-both panels with filtering. `src/tui/mode/overlay/palette.zig`
-implements much of the required functionality.
+One medium sized project is to create a widget that has one input
+widget with two panels, on the left, the list of options and, on the
+right, the preview of the selected option and offer various keybindings
+to manipulate the objects inside both panels with filtering.
 
 []($section.id('next'))
 ## Next steps
@@ -73,10 +66,11 @@ implements much of the required functionality.
 Said all of this, it's possible to start contributing via pull
 requesting [keybinds](/docs/architecture/keybind),
 [commands](/docs/architecture/command),
-[palettes](/docs/architecture/palette), or the **hx picker**.
+[palettes](/docs/architecture/palette), or the special widget
+mentioned previously.
 
 More about the [architecture](/docs/architecture) or jump to
 [contribution guidelines](/docs/contributing).
 
 Join the [#helix-mode channel](https://discord.gg/sxdejrAA) and get in
-touch with other hx mode and helix interested users.
+touch with other hx users. 

contrib/symbolnerdfontmonolist.txt

@@ -7,5 +7,3 @@ U+eda4
 U+e8ef
 U+f044
 U+ed7b
-U+f142
-U+f4eb