diff --git a/autoload/pathogen.vim b/autoload/pathogen.vim
index a13ae08f..5b62c5c9 100755
--- a/autoload/pathogen.vim
+++ b/autoload/pathogen.vim
@@ -10,22 +10,89 @@
 "
 " The API is documented inline below.
 
+" si ya se cargó este archivo o la compatibilidad con Vi está activada
 if exists("g:loaded_pathogen") || &cp
+
+" termina la carga acá
   finish
+
 endif
+
 let g:loaded_pathogen = 1
 
-" Point of entry for basic default usage.  Give a relative path to invoke
-" pathogen#interpose() (defaults to "bundle/{}"), or an absolute path to invoke
-" pathogen#surround().  Curly braces are expanded with pathogen#expand():
-" "bundle/{}" finds all subdirectories inside "bundle" inside all directories
-" in the runtime path.
+" Point of entry for basic default usage. Give a relative path to invoke pathogen#interpose()
+" (defaults to "bundle/{}"), or an absolute path to invoke pathogen#surround(). Curly braces are
+" expanded with pathogen#expand(): "bundle/{}" finds all subdirectories inside "bundle" inside all
+" directories in the runtime path.
+
+" !: si hay una función definida con el mismo identificador, la reemplaza
+" ...: acepta 0 o más argumentos
+" abort: termina la ejecución de la función al primer error
 function! pathogen#infect(...) abort
+
+  " para cada elemento en
+  "     si hay argumentos
+  "         se realiza una copia de la lista de los argumentos
+  "         se invierten los elementos de la lista
+  "         se eliminan los argumentos que no sean de tipo string
+  "     sino
+  "         una lista con un elemento = 'bundle/{}'
   for path in a:0 ? filter(reverse(copy(a:000)), 'type(v:val) == type("")') : ['bundle/{}']
+
+    " si el elemento es igual (case sensitive) a
+        " 1. ^: principio de línea
+        " 2. \%(: comienzo de grupo
+            " 3. "{"
+            " 4. \=: encuentra 0 o 1 vez el elemento anterior
+            " 5. [: comienzo de colección
+                " 6. "$"
+                " 7. "~"
+                " 8. \\: "\"
+                " 9. "/"
+            " 10. ]: fin de la colección que comenzó en (5.)
+        " 11. \|: OR
+            " 12. "{"
+            " 13. \=: encuentra 0 o 1 vez el elemento anterior
+            " 14. \w: igual a [0-9A-Za-z_]
+            " 15. ":"
+            " 16. [: comienzo de colección
+                " 17. \\: "\"
+                " 18. "/"
+            " 19. ]: fin de colección (16.)
+        " 20. \): fin de grupo (2.)
+        " 21. .: cualquier carácter menos fin de línea
+        " 22. *: encuentra 0 o más veces el elemento anterior
+        " 23. [: comienzo de colección
+            " 24. "{"
+            " 25. "}"
+            " 26. "*"
+        " 27. ]: fin de colección (23.)
     if path =~# '^\%({\=[$~\\/]\|{\=\w:[\\/]\).*[{}*]'
+
       call pathogen#surround(path)
+
+    " si el elemento es igual (case sensitive) a
+        " 1. ^: comienzo de línea
+        " 2. \%(: inicio de grupo
+            " 3. [: inicio de colección
+                " 4. "$"
+                " 5. "~"
+                " 6. \\: "\"
+                " 7. "/"
+            " 8. ]: fin de colección
+        " 9. \|: OR
+            " 10. \w: igual a [0-9A-Za-z_]
+            " 11. ":"
+            " 12. [: inicio de colección
+                " 13. \\: "\"
+                " 14. "/"
+            " 15. ]: fin de colección
+        " 16. \): fin de grupo
     elseif path =~# '^\%([$~\\/]\|\w:[\\/]\)'
+
+      " parámetro: un texto que avisa que al parámetro de pathogen#infect se le agrega '/{}'
       call s:warn('Change pathogen#infect('.string(path).') to pathogen#infect('.string(path.'/{}').')')
+
       call pathogen#surround(path . '/{}')
     elseif path =~# '[{}*]'
       call pathogen#interpose(path)
@@ -43,8 +110,15 @@ endfunction
 
 " Split a path into a list.
 function! pathogen#split(path) abort
+
+  " |: se utiliza para separar comandos en una misma línea
+  " si path es una lista, entonces devuelve path
   if type(a:path) == type([]) | return a:path | endif
+
+  " si path no contiene elementos, devuelve una lista vacía
   if empty(a:path) | return [] | endif
+
+  " la variable 'split' = 
   let split = split(a:path,'\\\@<!\%(\\\\\)*\zs,')
   return map(split,'substitute(v:val,''\\\([\\,]\)'',''\1'',"g")')
 endfunction
diff --git a/pendiente.txt b/pendiente.txt
index e69de29b..d40639b4 100644
--- a/pendiente.txt
+++ b/pendiente.txt
@@ -0,0 +1,3 @@
+- en algunas ocaciones, 'end' queda una indentación atrás cuando se tipea '$b' en modo VISUAL
+- cuando se reconozca que los archivos a editar son de lenguajes de programación, debería configurar 'set tw=0'
+- modificar el mapeo <space>p<space> de manera que se pueda usar con cualquier registro, y no sólo con el registro "
diff --git a/vimrcs/basic.vim b/vimrcs/basic.vim
index 67e254b3..0a1d82ff 100644
--- a/vimrcs/basic.vim
+++ b/vimrcs/basic.vim
@@ -43,7 +43,10 @@ let g:mapleader = ","
 nmap <leader>w :w!<cr>
 
 " sale de todas las ventanas
-map <leader>q :qa<cr>
+map <leader><space>q :qa<cr>
+
+" sale de la ventana actual
+map <leader>q :q<cr>
 
 " volver al modo normal sin tener que retirar los dedos de la posición normal en el teclado
 ino ñjaf <esc>
@@ -269,6 +272,9 @@ set statusline=\ %{HasPaste()}%F%m%r%h\ %w\ \ CWD:\ %r%{getcwd()}%h\ \ \ Line:\
 " remapea '0' para que posicione el cursor en el primer carácter no blanco
 map 0 ^
 
+" en vez de copiar toda la línea, copia desde el cursor hasta el final de la línea
+map Y y$
+
 " colocación de espacios sin tener que entrar en modo INSERT
 nn <space>k<space> O<esc>j
 nn <space>kk O<esc>
diff --git a/vimrcs/extended.vim b/vimrcs/extended.vim
index 8fa60046..f85d52ee 100644
--- a/vimrcs/extended.vim
+++ b/vimrcs/extended.vim
@@ -80,25 +80,39 @@ imap ½ $
 """""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
 " => Parenthesis/bracket
 """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
-" autocompletado de (, ", ', [, [[[, {{{}}} en modo VISUAL
+
+" autocompletado en modo VISUAL
 vnoremap $1 <esc>`>a)<esc>`<i(<esc> 
 vnoremap $2 <esc>`>a]<esc>`<i[<esc>
 vnoremap $3 <esc>`>a}<esc>`<i{<esc>
-vnoremap $$ <esc>`>a"<esc>`<i"<esc>
-vnoremap $q <esc>`>a'<esc>`<i'<esc>
-vnoremap $e <esc>`>a"<esc>`<i"<esc>
-vnoremap $f <esc>`<a<space>{{{<esc>`>i}}}<esc>
+vnoremap $' <esc>`>a'<esc>`<i'<esc>
+vnoremap $" <esc>`>a"<esc>`<i"<esc>
+vnoremap $* <esc>`>a*<esc>`<i*<esc>
+vnoremap $> <esc>`>a><esc>`<i<<esc>
+vnoremap $? <esc>`>a?<esc>`<i¿<esc>
+vnoremap $= <esc>`>o=<esc>yl99p`<O=<esc>yl99p
 vnoremap $b <esc>`<Obegin<esc>`>oend<esc>`<V`>>
+vnoremap $f <esc>`<A<space>{{{<esc>`>i}}}<esc>zxza
 
-" autocompletado de (, ", ', [, {{{}}} en modo INSERT
+" autocompletado en modo INSERT
 inoremap $1 ()<esc>i
 inoremap $2 []<esc>i
 inoremap $3 {}<esc>i
 inoremap $4 {<esc>o}<esc>O
-inoremap $q ''<esc>i
-inoremap $e ""<esc>i
-inoremap $f {{{<esc>o}}}<esc>O<esc>i
+inoremap $' ''<esc>i
+inoremap $" ""<esc>i
+inoremap $* **<esc>i
+inoremap $> <><esc>i
+inoremap $? ¿?<esc>i
+inoremap $= =<esc>yl99pYpO
 inoremap $b begin<cr><bs>end<esc>O
+inoremap $f <space>{{{<esc>o}}}<esc>O<esc>zxi
+inoremap $<space>f <esc>?*<cr>v`>$f
+
+" autocompletado en modo NORMAL
+nmap $* I*<esc>A*<esc>
+nmap $f $a<space>{{{<esc>o}}}<esc>O<esc>zxi
+nmap $<space>f v?*<cr><esc>`<a<space>{{{<esc>`>i}}}<esc>zxza
 
 " saltarse del paréntesis final sin tener que salir del modo INSERT
 inoremap $$ <esc>la