Update lspconfig, add indent-blanklineHEADmaster

indent-blankline is probably old because I've actually been using it for
ages, but I have a strict if-it-ain't-broke policy, so I'm not going to
update it.

lspconfig *was* broke though with nvim 0.10, so now it's fixed.

6 files changed, 1896 insertions, 0 deletions

diff --git a/start/indent-blankline-2.20.4/LICENSE.md b/start/indent-blankline-2.20.4/LICENSE.md
new file mode 100644
index 0000000..7074561
--- /dev/null
+++ b/start/indent-blankline-2.20.4/LICENSE.md
@@ -0,0 +1,21 @@
+The MIT Licence
+
+Copyright (c) 2022 Lukas Reineke
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/start/indent-blankline-2.20.4/doc/indent_blankline.txt b/start/indent-blankline-2.20.4/doc/indent_blankline.txt
new file mode 100644
index 0000000..d3975e8
--- /dev/null
+++ b/start/indent-blankline-2.20.4/doc/indent_blankline.txt
@@ -0,0 +1,784 @@
+*indent_blankline.txt*        Show vertical lines for indent on empty lines
+
+
+Author: Lukas Reineke <lukas.reineke@protonmail.com>
+Version: 2.20.4
+
+==============================================================================
+CONTENTS                                                    *indent-blankline*
+
+  1. Introduction                          |indent-blankline-introduction|
+  2. Highlights                            |indent-blankline-highlights|
+  3. Setup                                 |indent-blankline-setup|
+  4. Variables                             |indent-blankline-variables|
+  5. Commands                              |indent-blankline-commands|
+  6. License                               |indent-blankline-license|
+
+==============================================================================
+ 1. INTRODUCTION                               *indent-blankline-introduction*
+
+This plugin adds indentation guides to all lines (including empty lines).
+
+It uses Neovim's virtual text feature and **no conceal**
+
+This plugin requires Neovim 0.5 or higher. It makes use of Neovim only
+features so it will not work in Vim.
+There is a legacy version of the plugin that supports Neovim 0.4 under the
+branch `version-1`
+
+==============================================================================
+ 2. HIGHLIGHTS                                   *indent-blankline-highlights*
+
+To change the highlighting of either the indent character, or the whitespace
+between indent characters, define or update these highlight groups.
+
+------------------------------------------------------------------------------
+IndentBlanklineChar                                   *hl-IndentBlanklineChar*
+
+    Highlight of indent character.
+
+    Default: takes guifg color from 'Whitespace'                             ~
+
+    Example: >
+
+        highlight IndentBlanklineChar guifg=#00FF00 gui=nocombine
+
+------------------------------------------------------------------------------
+IndentBlanklineSpaceChar                         *hl-IndentBlanklineSpaceChar*
+
+    Highlight of space character.
+
+    Default: takes guifg color from 'Whitespace'                             ~
+
+    Example: >
+
+        highlight IndentBlanklineSpaceChar guifg=#00FF00 gui=nocombine
+
+------------------------------------------------------------------------------
+IndentBlanklineSpaceCharBlankline       *hl-IndentBlanklineSpaceCharBlankline*
+
+    Highlight of space character on blank lines.
+
+    Default: takes guifg color from 'Whitespace'                             ~
+
+    Example: >
+
+        highlight IndentBlanklineSpaceCharBlankline guifg=#00FF00 gui=nocombine
+
+------------------------------------------------------------------------------
+IndentBlanklineContextChar                     *hl-IndentBlanklineContextChar*
+
+    Highlight of indent character when base of current context.
+    Only used when |g:indent_blankline_show_current_context| is active
+
+    Default: takes guifg color from 'Label'                             ~
+
+    Example: >
+
+        highlight IndentBlanklineContextChar guifg=#00FF00 gui=nocombine
+
+------------------------------------------------------------------------------
+IndentBlanklineContextSpaceChar           *hl-IndentBlanklineContextSpaceChar*
+
+    Highlight of space characters one indent level of the current context.
+    Only used when |g:indent_blankline_show_current_context| is active
+
+    Default: takes guifg color from 'Label'                             ~
+
+    Example: >
+
+        highlight IndentBlanklineContextSpaceChar guifg=#00FF00 gui=nocombine
+
+------------------------------------------------------------------------------
+IndentBlanklineContextStart                     *hl-IndentBlanklineContextStart*
+
+    Highlight of the first line of the current context.
+    Only used when |g:indent_blankline_show_current_context_start| is active
+
+    Default: takes guifg color from 'Label' as guisp and adds underline      ~
+
+    Note: You need to have set |gui-colors| for the default to work.
+
+    Example: >
+
+        highlight IndentBlanklineContextStart guisp=#00FF00 gui=underline
+
+------------------------------------------------------------------------------
+
+Note: Define your highlight group after setting colorscheme or your colorscheme will clear your highlight group
+
+When defining the highlight group, it is important to set |nocombine| as a
+gui option. This is to make sure the character does not inherit gui options
+from the underlying text, like italic or bold.
+
+Highlight groups get reset on |ColorScheme| autocommand, if both fg and bg
+are empty.
+
+The set more than one highlight group that changes based on indentation level,
+see:
+|g:indent_blankline_char_highlight_list|
+|g:indent_blankline_space_char_highlight_list|
+|g:indent_blankline_space_char_blankline_highlight_list|
+
+==============================================================================
+ 3. SETUP                                             *indent-blankline-setup*
+
+To configure indent-blankline, either run the setup function, or set variables
+manually.
+The setup function has a single table as argument, keys of the table match the
+|indent-blankline-variables| without the `indent_blankline_` part.
+
+Example: >
+
+    require("indent_blankline").setup {
+        -- for example, context is off by default, use this to turn it on
+        show_current_context = true,
+        show_current_context_start = true,
+    }
+
+==============================================================================
+ 4. VARIABLES                                     *indent-blankline-variables*
+
+All variables can be set globally |g:var|, per tab |t:var|, or per buffer |b:var|
+
+------------------------------------------------------------------------------
+g:indent_blankline_char                              *g:indent_blankline_char*
+
+    Specifies the character to be used as indent line.
+    Not used if |g:indent_blankline_char_list| is not empty.
+
+    When set explicitly to empty string (""), no indentation character is
+    displayed at all, even when |g:indent_blankline_char_list| is not empty.
+    This can be useful in combination with
+    |g:indent_blankline_space_char_highlight_list| to only rely on different
+    highlighting of different indentation levels without needing to show a
+    special character.
+
+    Also set by |g:indentLine_char|
+
+    Default: '│'                                                             ~
+
+    Example: >
+
+        let g:indent_blankline_char = '|'
+
+------------------------------------------------------------------------------
+g:indent_blankline_char_blankline          *g:indent_blankline_char_blankline*
+
+    Specifies the character to be used as indent line for blanklines.
+    Not used if |g:indent_blankline_char_list_blankline| is not empty.
+
+    Default: ''                                                             ~
+
+    Example: >
+
+        let g:indent_blankline_char_blankline = '┆'
+
+------------------------------------------------------------------------------
+g:indent_blankline_char_list                    *g:indent_blankline_char_list*
+
+    Specifies a list of characters to be used as indent line for
+    each indentation level.
+    Ignored if the value is an empty list.
+
+    Also set by |g:indentLine_char_list|
+
+    Default: []                                                              ~
+
+    Example: >
+
+        let g:indent_blankline_char_list = ['|', '¦', '┆', '┊']
+
+------------------------------------------------------------------------------
+g:indent_blankline_char_list_blankline *g:indent_blankline_char_list_blankline*
+
+    Specifies a list of characters to be used as indent line for
+    each indentation level on blanklines.
+    Ignored if the value is an empty list.
+
+    Default: []                                                              ~
+
+    Example: >
+
+        let g:indent_blankline_char_list_blankline = ['|', '¦', '┆', '┊']
+
+------------------------------------------------------------------------------
+
+g:indent_blankline_char_highlight_list *g:indent_blankline_char_highlight_list*
+
+    Specifies the list of character highlights for each indentation level.
+    Ignored if the value is an empty list.
+
+    Default: []                                                              ~
+
+    Example: >
+
+        let g:indent_blankline_char_highlight_list = ['Error', 'Function']
+
+------------------------------------------------------------------------------
+g:indent_blankline_space_char_blankline *g:indent_blankline_space_char_blankline*
+
+    Specifies the character to be used as the space value in between indent
+    lines when the line is blank.
+
+    Default: An empty space character                                        ~
+
+    Example: >
+
+        let g:indent_blankline_space_char_blankline = ' '
+
+------------------------------------------------------------------------------
+
+g:indent_blankline_space_char_highlight_list *g:indent_blankline_space_char_highlight_list*
+
+    Specifies the list of space character highlights for each indentation
+    level.
+    Ignored if the value is an empty list.
+
+    Default: []                                                              ~
+
+    Example: >
+
+        let g:indent_blankline_space_char_highlight_list = ['Error', 'Function']
+
+------------------------------------------------------------------------------
+
+g:indent_blankline_space_char_blankline_highlight_list *g:indent_blankline_space_char_blankline_highlight_list*
+
+    Specifies the list of space character highlights for each indentation
+    level when the line is empty.
+    Ignored if the value is an empty list.
+
+    Also set by |g:indent_blankline_space_char_highlight_list|
+
+    Default: []                                                              ~
+
+    Example: >
+
+        let g:indent_blankline_space_char_blankline_highlight_list = ['Error', 'Function']
+
+------------------------------------------------------------------------------
+g:indent_blankline_use_treesitter          *g:indent_blankline_use_treesitter*
+
+    Use treesitter to calculate indentation when possible.
+    Requires treesitter
+
+    Default: false                                                           ~
+
+    Example: >
+
+        let g:indent_blankline_use_treesitter = v:true
+
+------------------------------------------------------------------------------
+g:indent_blankline_indent_level              *g:indent_blankline_indent_level*
+
+    Specifies the maximum indent level to display.
+
+    Also set by |g:indentLine_indentLevel|
+
+    Default: 10                                                              ~
+
+    Example: >
+
+        let g:indent_blankline_indent_level = 4
+
+------------------------------------------------------------------------------
+g:indent_blankline_max_indent_increase  *g:indent_blankline_max_indent_increase*
+
+    The maximum indent level increase from line to line.
+    Set this option to 1 to make aligned trailing multiline comments not
+    create indentation.
+
+    Default: g:indent_blankline_indent_level                                 ~
+
+    Example: >
+
+        let g:indent_blankline_max_indent_increase = 1
+
+------------------------------------------------------------------------------
+g:indent_blankline_show_first_indent_level *g:indent_blankline_show_first_indent_level*
+
+    Displays indentation in the first column.
+
+    Default: v:true                                                         ~
+
+    Example: >
+
+        let g:indent_blankline_show_first_indent_level = v:false
+
+------------------------------------------------------------------------------
+g:indent_blankline_show_trailing_blankline_indent *g:indent_blankline_show_trailing_blankline_indent*
+
+    Displays a trailing indentation guide on blank lines, to match the
+    indentation of surrounding code.
+    Turn this off if you want to use background highlighting instead of chars.
+
+    Default: v:true                                                         ~
+
+    Example: >
+
+        let g:indent_blankline_show_trailing_blankline_indent = v:false
+
+------------------------------------------------------------------------------
+g:indent_blankline_show_end_of_line      *g:indent_blankline_show_end_of_line*
+
+    Displays the end of line character set by |listchars| instead of the
+    indent guide on line returns.
+
+    Default: v:false                                                         ~
+
+    Example: >
+
+        let g:indent_blankline_show_end_of_line = v:true
+
+------------------------------------------------------------------------------
+g:indent_blankline_show_foldtext            *g:indent_blankline_show_foldtext*
+
+    Displays the full fold text instead of the indent guide on folded lines.
+
+    Note: there is no autocommand to subscribe to changes in folding. This
+          might lead to unexpected results. A possible solution for this is to
+          remap folding bindings to also call |IndentBlanklineRefresh|
+
+    Default: v:true                                                         ~
+
+    Example: >
+
+        let g:indent_blankline_show_foldtext = v:false
+
+------------------------------------------------------------------------------
+g:indent_blankline_enabled                        *g:indent_blankline_enabled*
+
+    Turns this plugin on or off.
+
+    Also set by |g:indentLine_enabled|
+
+    Note: the buffer version of this variable overwrites all other
+          enabled/disabled checks.
+
+    Default: v:true                                                          ~
+
+    Example: >
+
+        let g:indent_blankline_enabled = v:false
+
+------------------------------------------------------------------------------
+g:indent_blankline_disable_with_nolist *g:indent_blankline_disable_with_nolist*
+
+    When true, automatically turns this plugin off when |nolist| is set.
+    When false, setting |nolist| will keep displaying indentation guides but
+    removes whitespace characters set by |listchars|.
+
+    Default: v:false                                                         ~
+
+    Example: >
+
+        let g:indent_blankline_disable_with_nolist = v:true
+
+------------------------------------------------------------------------------
+g:indent_blankline_filetype                      *g:indent_blankline_filetype*
+
+    Specifies a list of |filetype| values for which this plugin is enabled.
+    All |filetypes| are enabled if the value is an empty list.
+
+    Also set by |g:indentLine_fileType|
+
+    Default: []                                                              ~
+
+    Example: >
+
+        let g:indent_blankline_filetype = ['vim']
+
+------------------------------------------------------------------------------
+g:indent_blankline_filetype_exclude      *g:indent_blankline_filetype_exclude*
+
+    Specifies a list of |filetype| values for which this plugin is not enabled.
+    Ignored if the value is an empty list.
+
+    Also set by |g:indentLine_fileTypeExclude|
+
+    Default: [                                                               ~
+        "lspinfo",                                                           ~
+        "packer",                                                            ~
+        "checkhealth",                                                       ~
+        "help",                                                              ~
+        "man",                                                               ~
+        "",                                                                  ~
+    ]                                                                        ~
+
+    Example: >
+
+        let g:indent_blankline_filetype_exclude = ['help']
+
+------------------------------------------------------------------------------
+g:indent_blankline_buftype_exclude        *g:indent_blankline_buftype_exclude*
+
+    Specifies a list of |buftype| values for which this plugin is not enabled.
+    Ignored if the value is an empty list.
+
+    Also set by |g:indentLine_bufTypeExclude|
+
+    Default: [                                                               ~
+        "terminal",                                                          ~
+        "nofile",                                                            ~
+        "quickfix",                                                          ~
+        "prompt",                                                            ~
+    ]                                                                        ~
+
+    Example: >
+
+        let g:indent_blankline_buftype_exclude = ['terminal']
+
+------------------------------------------------------------------------------
+g:indent_blankline_bufname_exclude        *g:indent_blankline_bufname_exclude*
+
+    Specifies a list of buffer names (file name with full path) for which
+    this plugin is not enabled.
+    A name can be regular expression as well.
+
+    Also set by |g:indentLine_bufNameExclude|
+
+    Default: []                                                              ~
+
+    Example: >
+
+        let g:indent_blankline_bufname_exclude = ['README.md', '.*\.py']
+
+------------------------------------------------------------------------------
+g:indent_blankline_strict_tabs                *g:indent_blankline_strict_tabs*
+
+    When on, if there is a single tab in a line, only tabs are used to
+    calculate the indentation level.
+    When off, both spaces and tabs are used to calculate the indentation
+    level.
+    Only makes a difference if a line has a mix of tabs and spaces for
+    indentation.
+
+    Default: v:false                                                         ~
+
+    Example: >
+
+        let g:indent_blankline_strict_tabs = v:true
+
+------------------------------------------------------------------------------
+g:indent_blankline_show_current_context *g:indent_blankline_show_current_context*
+
+    When on, use treesitter to determine the current context. Then show the
+    indent character in a different highlight.
+
+    Note: Requires https://github.com/nvim-treesitter/nvim-treesitter to be
+          installed
+
+    Note: With this option enabled, the plugin refreshes on |CursorMoved|,
+          which might be slower
+
+    Default: v:false                                                         ~
+
+    Example: >
+
+        let g:indent_blankline_show_current_context = v:true
+
+------------------------------------------------------------------------------
+g:indent_blankline_show_current_context_start *g:indent_blankline_show_current_context_start*
+
+    Applies the |hl-IndentBlanklineContextStart| highlight group to the first
+    line of the current context.
+    By default this will underline.
+
+    Note: Requires https://github.com/nvim-treesitter/nvim-treesitter to be
+          installed
+
+    Note: You need to have set |gui-colors| and it depends on your terminal
+          emulator if this works as expected.
+          If you are using kitty and tmux, take a look at this article to
+          make it work
+          http://evantravers.com/articles/2021/02/05/curly-underlines-in-kitty-tmux-neovim/
+
+    Default: v:false                                                         ~
+
+    Example: >
+
+        let g:indent_blankline_show_current_context_start = v:true
+
+------------------------------------------------------------------------------
+g:indent_blankline_show_current_context_start_on_current_line *g:indent_blankline_show_current_context_start_on_current_line*
+
+    Shows |g:indent_blankline_show_current_context_start| even when the cursor
+    is on the same line
+
+    Default: v:true                                                         ~
+
+    Example: >
+
+        let g:indent_blankline_show_current_context_start_on_current_line = v:false
+
+------------------------------------------------------------------------------
+g:indent_blankline_context_char              *g:indent_blankline_context_char*
+
+    Specifies the character to be used for the current context indent line.
+    Not used if |g:indent_blankline_context_char_list| is not empty.
+
+    Useful to have a greater distinction between the current context indent
+    line and others.
+
+    Also useful in combination with |g:indent_blankline_char| set to empty string
+    (""), as this allows only the current context indent line to be shown.
+
+    Default: g:indent_blankline_char                                         ~
+
+    Example: >
+
+        let g:indent_blankline_context_char = '┃'
+
+------------------------------------------------------------------------------
+g:indent_blankline_context_char_blankline *g:indent_blankline_context_char_blankline*
+
+    Equivalent of |g:indent_blankline_char_blankline| for
+    |g:indent_blankline_context_char|.
+
+    Default: ''                                                             ~
+
+    Example: >
+
+        let g:indent_blankline_context_char_blankline = '┆'
+
+------------------------------------------------------------------------------
+g:indent_blankline_context_char_list    *g:indent_blankline_context_char_list*
+
+    Equivalent of |g:indent_blankline_char_list| for
+    |g:indent_blankline_context_char|.
+
+    Default: []                                                              ~
+
+    Example: >
+
+        let g:indent_blankline_context_char_list = ['┃', '║', '╬', '█']
+
+------------------------------------------------------------------------------
+g:indent_blankline_context_char_list_blankline *g:indent_blankline_context_char_list_blankline*
+
+    Equivalent of |g:indent_blankline_char_list_blankline| for
+    |g:indent_blankline_context_char_blankline|.
+
+    Default: []                                                              ~
+
+    Example: >
+
+        let g:indent_blankline_context_char_list_blankline = ['┃', '║', '╬', '█']
+
+------------------------------------------------------------------------------
+g:indent_blankline_context_highlight_list *g:indent_blankline_context_highlight_list*
+
+    Specifies the list of character highlights for the current context at
+    each indentation level.
+    Ignored if the value is an empty list.
+
+    Only used when |g:indent_blankline_show_current_context| is active
+
+    Default: []                                                              ~
+
+    Example: >
+
+        let g:indent_blankline_context_highlight_list = ['Error', 'Warning']
+
+------------------------------------------------------------------------------
+g:indent_blankline_char_priority            *g:indent_blankline_char_priority*
+
+    Specifies the |extmarks| priority for chars.
+
+    Default: 1                                                               ~
+
+    Example: >
+
+        let g:indent_blankline_char_priority = 50
+
+------------------------------------------------------------------------------
+g:indent_blankline_context_start_priority *g:indent_blankline_context_start_priority*
+
+    Specifies the |extmarks| priority for the context start.
+
+    Default: 10000                                                           ~
+
+    Example: >
+
+        let g:indent_blankline_context_start_priority = 50
+
+------------------------------------------------------------------------------
+g:indent_blankline_context_patterns      *g:indent_blankline_context_patterns*
+
+    Specifies a list of lua patterns that are used to match against the
+    treesitter |tsnode:type()| at the cursor position to find the current
+    context.
+
+    To learn more about how lua pattern work, see here:
+    https://www.lua.org/manual/5.1/manual.html#5.4.1
+
+    Only used when |g:indent_blankline_show_current_context| is active
+
+    Default: [                                                               ~
+        "class",                                                             ~
+        "^func",                                                             ~
+        "method",                                                            ~
+        "^if",                                                               ~
+        "while",                                                             ~
+        "for",                                                               ~
+        "with",                                                              ~
+        "try",                                                               ~
+        "except",                                                            ~
+        "arguments",                                                         ~
+        "argument_list",                                                     ~
+        "object",                                                            ~
+        "dictionary",                                                        ~
+        "element",                                                           ~
+        "table",                                                             ~
+        "tuple",                                                             ~
+        "do_block",                                                          ~
+    ]                                                                        ~
+
+    Example: >
+
+        let g:indent_blankline_context_patterns = ['^if']
+
+------------------------------------------------------------------------------
+g:indent_blankline_use_treesitter_scope *g:indent_blankline_use_treesitter_scope*
+
+    Instead of using |g:indent_blankline_context_patterns|, use the current
+    scope defined by nvim-treesitter as the context.
+
+    Default: false                                                           ~
+
+    Example: >
+
+        let g:indent_blankline_use_treesitter_scope = true
+
+------------------------------------------------------------------------------
+g:indent_blankline_context_pattern_highlight *g:indent_blankline_context_pattern_highlight*
+
+    Specifies a map of patterns set in
+    |g:indent_blankline_context_patterns| to highlight groups.
+    When the current matching context pattern is in the map, the context
+    will be highlighted with the corresponding highlight group.
+
+    Only used when |g:indent_blankline_show_current_context| is active
+
+    Default: {}                                                              ~
+
+    Example: >
+
+        let g:indent_blankline_context_pattern_highlight = {'function': 'Function'}
+
+------------------------------------------------------------------------------
+g:indent_blankline_viewport_buffer        *g:indent_blankline_viewport_buffer*
+
+    Sets the buffer of extra lines before and after the current viewport that
+    are considered when generating indentation and the context.
+
+    Default: 10                                                              ~
+
+    Example: >
+
+        let g:indent_blankline_viewport_buffer = 20
+
+------------------------------------------------------------------------------
+g:indent_blankline_disable_warning_message *g:indent_blankline_disable_warning_message*
+
+    Turns deprecation warning messages off.
+
+    Default: v:false                                                         ~
+
+    Example: >
+
+        let g:indent_blankline_disable_warning_message = v:true
+
+==============================================================================
+ 5. COMMANDS                                       *indent-blankline-commands*
+
+------------------------------------------------------------------------------
+:IndentBlanklineRefresh[!]                            *IndentBlanklineRefresh*
+
+    Refreshes the indent guides for the current buffer.
+    Run this with |autocmd| when the file changes. For example after a plugin
+    formats the file.
+
+    With bang (IndentBlanklineRefresh!) refreshes the indent guides globally.
+
+    By default it is run for:
+      1. |FileChangedShellPost| *
+      2. |TextChanged| *
+      3. |TextChangedI| *
+      4. |CompleteChanged| *
+      5. |BufWinEnter| *
+      6. |Filetype| *
+      7. |OptionSet| list,listchars,shiftwidth,tabstop,expandtab
+
+    Example: >
+
+        autocmd User ALEFixPost IndentBlanklineRefresh
+
+------------------------------------------------------------------------------
+:IndentBlanklineRefreshScroll[!]                *IndentBlanklineRefreshScroll*
+
+    Refreshes the indent guides for the current buffer. But tries to reuse as
+    indent guides that already exist. Only used if we are sure the buffer
+    content did not change.
+
+    With bang (IndentBlanklineRefresh!) refreshes the indent guides globally.
+
+    By default it is run for:
+      1. |WinScrolled| *
+
+    Example: >
+
+        autocmd WinScrolled * IndentBlanklineRefreshScroll
+
+------------------------------------------------------------------------------
+:IndentBlanklineEnable[!]                               *IndentBlanklineEnable*
+
+    Enables this plugin for the current buffer.
+    This overwrites any include/exclude rules.
+
+    With bang (IndentBlanklineEnable!) enables this plugin globally
+
+------------------------------------------------------------------------------
+:IndentBlanklineDisable[!]                            *IndentBlanklineDisable*
+
+    Disables this plugin for the current buffer.
+    This overwrites any include/exclude rules.
+
+    With bang (IndentBlanklineDisable!) disables this plugin globally
+
+------------------------------------------------------------------------------
+:IndentBlanklineToggle[!]                              *IndentBlanklineToggle*
+
+    Toggles between |IndentBlanklineEnable| and |IndentBlanklineDisable|.
+
+    With bang (IndentBlanklineToggle!) toggles globally
+
+==============================================================================
+ 6. LICENSE                                         *indent-blankline-license*
+
+The MIT Licence
+http://www.opensource.org/licenses/mit-license.php
+
+Copyright (c) 2023 Lukas Reineke
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+==============================================================================
+vim:tw=78:ts=8:ft=help:norl
diff --git a/start/indent-blankline-2.20.4/lua/indent_blankline/commands.lua b/start/indent-blankline-2.20.4/lua/indent_blankline/commands.lua
new file mode 100644
index 0000000..263d332
--- /dev/null
+++ b/start/indent-blankline-2.20.4/lua/indent_blankline/commands.lua
@@ -0,0 +1,58 @@
+local M = {}
+
+M.refresh = function(bang, scroll)
+    scroll = scroll or false
+    if bang then
+        local win = vim.api.nvim_get_current_win()
+        vim.cmd(string.format([[noautocmd windo lua require("indent_blankline").refresh(%s)]], tostring(scroll)))
+        if vim.api.nvim_win_is_valid(win) then
+            vim.api.nvim_set_current_win(win)
+        end
+    else
+        require("indent_blankline").refresh(scroll)
+    end
+end
+
+M.enable = function(bang)
+    if bang then
+        vim.g.indent_blankline_enabled = true
+        local win = vim.api.nvim_get_current_win()
+        vim.cmd [[noautocmd windo lua require("indent_blankline").refresh(false)]]
+        vim.api.nvim_set_current_win(win)
+    else
+        vim.b.indent_blankline_enabled = true
+        require("indent_blankline").refresh(false)
+    end
+end
+
+M.disable = function(bang)
+    if bang then
+        vim.g.indent_blankline_enabled = false
+        local buffers = vim.api.nvim_list_bufs()
+        for _, buffer in pairs(buffers) do
+            vim.api.nvim_buf_clear_namespace(buffer, vim.g.indent_blankline_namespace, 1, -1)
+        end
+    else
+        vim.b.indent_blankline_enabled = false
+        vim.b.__indent_blankline_active = false
+        vim.api.nvim_buf_clear_namespace(0, vim.g.indent_blankline_namespace, 1, -1)
+    end
+end
+
+M.toggle = function(bang)
+    if bang then
+        if vim.g.indent_blankline_enabled then
+            M.disable(bang)
+        else
+            M.enable(bang)
+        end
+    else
+        if vim.b.__indent_blankline_active then
+            M.disable(bang)
+        else
+            M.enable(bang)
+        end
+    end
+end
+
+return M
diff --git a/start/indent-blankline-2.20.4/lua/indent_blankline/init.lua b/start/indent-blankline-2.20.4/lua/indent_blankline/init.lua
new file mode 100644
index 0000000..129458e
--- /dev/null
+++ b/start/indent-blankline-2.20.4/lua/indent_blankline/init.lua
@@ -0,0 +1,651 @@
+local utils = require "indent_blankline/utils"
+local M = {}
+
+local char_highlight = "IndentBlanklineChar"
+local space_char_highlight = "IndentBlanklineSpaceChar"
+local space_char_blankline_highlight = "IndentBlanklineSpaceCharBlankline"
+local context_highlight = "IndentBlanklineContextChar"
+local context_space_char_highlight = "IndentBlanklineContextSpaceChar"
+
+M.init = function()
+    if not vim.g.indent_blankline_namespace then
+        vim.g.indent_blankline_namespace = vim.api.nvim_create_namespace "indent_blankline"
+    end
+
+    utils.reset_highlights()
+
+    require("indent_blankline.commands").refresh(true)
+end
+
+M.setup = function(options)
+    if options == nil then
+        options = {}
+    end
+
+    local o = utils.first_not_nil
+
+    vim.g.indent_blankline_char = o(options.char, vim.g.indent_blankline_char, vim.g.indentLine_char, "│")
+    vim.g.indent_blankline_char_blankline = o(options.char_blankline, vim.g.indent_blankline_char_blankline)
+    vim.g.indent_blankline_char_list =
+        o(options.char_list, vim.g.indent_blankline_char_list, vim.g.indentLine_char_list)
+    vim.g.indent_blankline_char_list_blankline =
+        o(options.char_list_blankline, vim.g.indent_blankline_char_list_blankline)
+    vim.g.indent_blankline_context_char =
+        o(options.context_char, vim.g.indent_blankline_context_char, vim.g.indent_blankline_char)
+    vim.g.indent_blankline_context_char_blankline = o(
+        options.context_char_blankline,
+        vim.g.indent_blankline_context_char_blankline,
+        vim.g.indent_blankline_char_blankline
+    )
+    vim.g.indent_blankline_context_char_list = o(options.context_char_list, vim.g.indent_blankline_context_char_list)
+    vim.g.indent_blankline_context_char_list_blankline =
+        o(options.context_char_list_blankline, vim.g.indent_blankline_context_char_list)
+    vim.g.indent_blankline_char_highlight_list =
+        o(options.char_highlight_list, vim.g.indent_blankline_char_highlight_list)
+    vim.g.indent_blankline_space_char_highlight_list =
+        o(options.space_char_highlight_list, vim.g.indent_blankline_space_char_highlight_list)
+    vim.g.indent_blankline_space_char_blankline =
+        o(options.space_char_blankline, vim.g.indent_blankline_space_char_blankline, " ")
+    vim.g.indent_blankline_space_char_blankline_highlight_list = o(
+        options.space_char_blankline_highlight_list,
+        vim.g.indent_blankline_space_char_blankline_highlight_list,
+        options.space_char_highlight_list,
+        vim.g.indent_blankline_space_char_highlight_list
+    )
+    vim.g.indent_blankline_indent_level = o(options.indent_level, vim.g.indent_blankline_indent_level, 20)
+    vim.g.indent_blankline_enabled = o(options.enabled, vim.g.indent_blankline_enabled, true)
+    vim.g.indent_blankline_disable_with_nolist =
+        o(options.disable_with_nolist, vim.g.indent_blankline_disable_with_nolist, false)
+    vim.g.indent_blankline_filetype = o(options.filetype, vim.g.indent_blankline_filetype, vim.g.indentLine_fileType)
+    vim.g.indent_blankline_filetype_exclude = o(
+        options.filetype_exclude,
+        vim.g.indent_blankline_filetype_exclude,
+        vim.g.indentLine_fileTypeExclude,
+        { "lspinfo", "packer", "checkhealth", "help", "man", "" }
+    )
+    vim.g.indent_blankline_bufname_exclude =
+        o(options.bufname_exclude, vim.g.indent_blankline_bufname_exclude, vim.g.indentLine_bufNameExclude)
+    vim.g.indent_blankline_buftype_exclude = o(
+        options.buftype_exclude,
+        vim.g.indent_blankline_buftype_exclude,
+        vim.g.indentLine_bufTypeExclude,
+        { "terminal", "nofile", "quickfix", "prompt" }
+    )
+    vim.g.indent_blankline_viewport_buffer = o(options.viewport_buffer, vim.g.indent_blankline_viewport_buffer, 10)
+    vim.g.indent_blankline_use_treesitter = o(options.use_treesitter, vim.g.indent_blankline_use_treesitter, false)
+    vim.g.indent_blankline_max_indent_increase = o(
+        options.max_indent_increase,
+        vim.g.indent_blankline_max_indent_increase,
+        options.indent_level,
+        vim.g.indent_blankline_indent_level
+    )
+    vim.g.indent_blankline_show_first_indent_level =
+        o(options.show_first_indent_level, vim.g.indent_blankline_show_first_indent_level, true)
+    vim.g.indent_blankline_show_trailing_blankline_indent =
+        o(options.show_trailing_blankline_indent, vim.g.indent_blankline_show_trailing_blankline_indent, true)
+    vim.g.indent_blankline_show_end_of_line =
+        o(options.show_end_of_line, vim.g.indent_blankline_show_end_of_line, false)
+    vim.g.indent_blankline_show_foldtext = o(options.show_foldtext, vim.g.indent_blankline_show_foldtext, true)
+    vim.g.indent_blankline_show_current_context =
+        o(options.show_current_context, vim.g.indent_blankline_show_current_context, false)
+    vim.g.indent_blankline_show_current_context_start =
+        o(options.show_current_context_start, vim.g.indent_blankline_show_current_context_start, false)
+    vim.g.indent_blankline_use_treesitter_scope =
+        o(options.use_treesitter_scope, vim.g.indent_blankline_use_treesitter_scope, false)
+    vim.g.indent_blankline_show_current_context_start_on_current_line = o(
+        options.show_current_context_start_on_current_line,
+        vim.g.indent_blankline_show_current_context_start_on_current_line,
+        true
+    )
+    vim.g.indent_blankline_context_highlight_list =
+        o(options.context_highlight_list, vim.g.indent_blankline_context_highlight_list)
+    vim.g.indent_blankline_context_patterns = o(options.context_patterns, vim.g.indent_blankline_context_patterns, {
+        "class",
+        "^func",
+        "method",
+        "^if",
+        "while",
+        "for",
+        "with",
+        "try",
+        "except",
+        "match",
+        "arguments",
+        "argument_list",
+        "object",
+        "dictionary",
+        "element",
+        "table",
+        "tuple",
+        "do_block",
+    })
+    vim.g.indent_blankline_context_pattern_highlight =
+        o(options.context_pattern_highlight, vim.g.indent_blankline_context_pattern_highlight)
+    vim.g.indent_blankline_strict_tabs = o(options.strict_tabs, vim.g.indent_blankline_strict_tabs, false)
+
+    vim.g.indent_blankline_disable_warning_message =
+        o(options.disable_warning_message, vim.g.indent_blankline_disable_warning_message, false)
+    vim.g.indent_blankline_char_priority = o(options.char_priority, vim.g.indent_blankline_char_priority, 1)
+    vim.g.indent_blankline_context_start_priority =
+        o(options.context_start_priority, vim.g.indent_blankline_context_start_priority, 10000)
+
+    if vim.g.indent_blankline_show_current_context then
+        vim.cmd [[
+            augroup IndentBlanklineContextAutogroup
+                autocmd!
+                autocmd CursorMoved,CursorMovedI * IndentBlanklineRefresh
+            augroup END
+        ]]
+    end
+
+    vim.g.__indent_blankline_setup_completed = true
+end
+
+local refresh = function(scroll)
+    local v = utils.get_variable
+    local bufnr = vim.api.nvim_get_current_buf()
+
+    if not vim.api.nvim_buf_is_loaded(bufnr) then
+        return
+    end
+
+    if
+        not utils.is_indent_blankline_enabled(
+            vim.b.indent_blankline_enabled,
+            vim.g.indent_blankline_enabled,
+            v "indent_blankline_disable_with_nolist",
+            vim.opt.list:get(),
+            vim.bo.filetype,
+            v "indent_blankline_filetype" or {},
+            v "indent_blankline_filetype_exclude",
+            vim.bo.buftype,
+            v "indent_blankline_buftype_exclude" or {},
+            v "indent_blankline_bufname_exclude" or {},
+            vim.fn["bufname"] ""
+        )
+    then
+        if vim.b.__indent_blankline_active then
+            vim.schedule_wrap(utils.clear_buf_indent)(bufnr)
+        end
+        vim.b.__indent_blankline_active = false
+        return
+    else
+        vim.b.__indent_blankline_active = true
+    end
+
+    local win_start = vim.fn.line "w0"
+    local win_end = vim.fn.line "w$"
+    local offset = math.max(win_start - 1 - v "indent_blankline_viewport_buffer", 0)
+    local win_view = vim.fn.winsaveview()
+    local left_offset = win_view.leftcol
+    local lnum = win_view.lnum
+    local left_offset_s = tostring(left_offset)
+    local range = math.min(win_end + v "indent_blankline_viewport_buffer", vim.api.nvim_buf_line_count(bufnr))
+
+    if not vim.b.__indent_blankline_ranges then
+        vim.b.__indent_blankline_ranges = {}
+    end
+
+    if scroll then
+        local updated_range
+
+        if vim.b.__indent_blankline_ranges[left_offset_s] then
+            local blankline_ranges = vim.b.__indent_blankline_ranges[left_offset_s]
+            local need_to_update = true
+
+            -- find a candidate that could contain the window
+            local idx_candidate = utils.binary_search_ranges(blankline_ranges, { win_start, win_end })
+            local candidate_start, candidate_end = unpack(blankline_ranges[idx_candidate])
+
+            -- check if the current window is contained or if a new range needs to be created
+            if candidate_start <= win_start then
+                if candidate_end >= win_end then
+                    need_to_update = false
+                else
+                    table.insert(blankline_ranges, idx_candidate + 1, { offset, range })
+                end
+            else
+                table.insert(blankline_ranges, idx_candidate, { offset, range })
+            end
+
+            if not need_to_update then
+                return
+            end
+
+            -- merge ranges and update the variable, strategies are: contains or extends
+            updated_range = utils.merge_ranges(blankline_ranges)
+        else
+            updated_range = { { offset, range } }
+        end
+
+        -- we can't assign directly to a table key, so we update the reference to the variable
+        local new_ranges = vim.b.__indent_blankline_ranges
+        new_ranges[left_offset_s] = updated_range
+        vim.b.__indent_blankline_ranges = new_ranges
+    else
+        vim.b.__indent_blankline_ranges = { [left_offset_s] = { { offset, range } } }
+    end
+
+    local lines = vim.api.nvim_buf_get_lines(bufnr, offset, range, false)
+    local char = v "indent_blankline_char"
+    local char_blankline = v "indent_blankline_char_blankline"
+    local char_list = v "indent_blankline_char_list" or {}
+    local char_list_blankline = v "indent_blankline_char_list_blankline" or {}
+    local context_char = v "indent_blankline_context_char"
+    local context_char_blankline = v "indent_blankline_context_char_blankline"
+    local context_char_list = v "indent_blankline_context_char_list" or {}
+    local context_char_list_blankline = v "indent_blankline_context_char_list_blankline" or {}
+    local char_highlight_list = v "indent_blankline_char_highlight_list" or {}
+    local space_char_highlight_list = v "indent_blankline_space_char_highlight_list" or {}
+    local space_char_blankline_highlight_list = v "indent_blankline_space_char_blankline_highlight_list" or {}
+    local space_char_blankline = v "indent_blankline_space_char_blankline"
+    local char_priority = v "indent_blankline_char_priority"
+    local context_start_priority = v "indent_blankline_context_start_priority"
+
+    local list_chars
+    local no_tab_character = false
+    -- No need to check for disable_with_nolist as this part would never be executed if "true" && nolist
+    if vim.opt.list:get() then
+        -- list is set, get listchars
+        local tab_characters
+        local space_character = vim.opt.listchars:get().space or " "
+        if vim.opt.listchars:get().tab then
+            -- tab characters can be any UTF-8 character, Lua 5.1 cannot handle this without external libraries
+            tab_characters = vim.fn.split(vim.opt.listchars:get().tab, "\\zs")
+        else
+            no_tab_character = true
+            tab_characters = { "^", "I" }
+        end
+        list_chars = {
+            space_char = space_character,
+            trail_char = vim.opt.listchars:get().trail or space_character,
+            lead_char = vim.opt.listchars:get().lead or space_character,
+            tab_char_start = tab_characters[1] or space_character,
+            tab_char_fill = tab_characters[2] or space_character,
+            tab_char_end = tab_characters[3],
+            eol_char = vim.opt.listchars:get().eol,
+        }
+    else
+        -- nolist is set, replace all listchars with empty space
+        list_chars = {
+            space_char = " ",
+            trail_char = " ",
+            lead_char = " ",
+            tab_char_start = " ",
+            tab_char_fill = " ",
+            tab_char_end = nil,
+            eol_char = nil,
+        }
+    end
+
+    local max_indent_level = v "indent_blankline_indent_level"
+    local max_indent_increase = v "indent_blankline_max_indent_increase"
+    local expandtab = vim.bo.expandtab
+    local use_ts_indent = false
+    local ts_indent
+    if v "indent_blankline_use_treesitter" then
+        local ts_query_status, ts_query = pcall(require, "nvim-treesitter.query")
+        if not ts_query_status then
+            vim.schedule_wrap(function()
+                utils.error_handler("nvim-treesitter not found. Treesitter indent will not work", vim.log.levels.WARN)
+            end)()
+        end
+        local ts_indent_status
+        ts_indent_status, ts_indent = pcall(require, "nvim-treesitter.indent")
+        use_ts_indent = ts_query_status and ts_indent_status and ts_query.has_indents(vim.bo.filetype)
+    end
+    local first_indent = v "indent_blankline_show_first_indent_level"
+    local trail_indent = v "indent_blankline_show_trailing_blankline_indent"
+    local end_of_line = v "indent_blankline_show_end_of_line"
+    local strict_tabs = v "indent_blankline_strict_tabs"
+    local foldtext = v "indent_blankline_show_foldtext"
+
+    local tabs = vim.bo.shiftwidth == 0 or not expandtab
+    local shiftwidth = utils._if(tabs, utils._if(no_tab_character, 2, vim.bo.tabstop), vim.bo.shiftwidth)
+
+    local context_highlight_list = v "indent_blankline_context_highlight_list" or {}
+    local context_pattern_highlight = v "indent_blankline_context_pattern_highlight" or {}
+    local context_status, context_start, context_end, context_pattern = false, 0, 0, nil
+    local show_current_context_start = v "indent_blankline_show_current_context_start"
+    local show_current_context_start_on_current_line = v "indent_blankline_show_current_context_start_on_current_line"
+    if v "indent_blankline_show_current_context" then
+        context_status, context_start, context_end, context_pattern =
+            utils.get_current_context(v "indent_blankline_context_patterns", v "indent_blankline_use_treesitter_scope")
+    end
+
+    local get_virtual_text =
+        function(indent, extra, blankline, context_active, context_indent, prev_indent, virtual_string)
+            local virtual_text = {}
+            local current_left_offset = left_offset
+            local local_max_indent_level = math.min(max_indent_level, prev_indent + max_indent_increase)
+            local indent_char = utils._if(blankline and char_blankline, char_blankline, char)
+            local context_indent_char =
+                utils._if(blankline and context_char_blankline, context_char_blankline, context_char)
+            local indent_char_list = utils._if(blankline and #char_list_blankline > 0, char_list_blankline, char_list)
+            local context_indent_char_list = utils._if(
+                blankline and #context_char_list_blankline > 0,
+                context_char_list_blankline,
+                context_char_list
+            )
+            for i = 1, math.min(math.max(indent, 0), local_max_indent_level) do
+                local space_count = shiftwidth
+                local context = context_active and context_indent == i
+                local show_indent_char = (i ~= 1 or first_indent) and indent_char ~= ""
+                local show_context_indent_char = context and (i ~= 1 or first_indent) and context_indent_char ~= ""
+                local show_end_of_line_char = i == 1 and blankline and end_of_line and list_chars["eol_char"]
+                local show_indent_or_eol_char = show_indent_char or show_context_indent_char or show_end_of_line_char
+                if show_indent_or_eol_char then
+                    space_count = space_count - 1
+                    if current_left_offset > 0 then
+                        current_left_offset = current_left_offset - 1
+                    else
+                        table.insert(virtual_text, {
+                            utils._if(
+                                show_end_of_line_char,
+                                list_chars["eol_char"],
+                                utils._if(
+                                    context,
+                                    utils.get_from_list(
+                                        context_indent_char_list,
+                                        i - utils._if(not first_indent, 1, 0),
+                                        context_indent_char
+                                    ),
+                                    utils.get_from_list(
+                                        indent_char_list,
+                                        i - utils._if(not first_indent, 1, 0),
+                                        indent_char
+                                    )
+                                )
+                            ),
+                            utils._if(
+                                context,
+                                utils._if(
+                                    context_pattern_highlight[context_pattern],
+                                    context_pattern_highlight[context_pattern],
+                                    utils.get_from_list(context_highlight_list, i, context_highlight)
+                                ),
+                                utils.get_from_list(char_highlight_list, i, char_highlight)
+                            ),
+                        })
+                    end
+                end
+                if current_left_offset > 0 then
+                    local current_space_count = space_count
+                    space_count = space_count - current_left_offset
+                    current_left_offset = current_left_offset - current_space_count
+                end
+                if space_count > 0 then
+                    -- ternary operator below in table.insert() doesn't work because it would evaluate each option regardless
+                    local tmp_string
+                    local index = 1 + (i - 1) * shiftwidth
+                    if show_indent_or_eol_char then
+                        if table.maxn(virtual_string) >= index + space_count then
+                            -- first char was already set above
+                            tmp_string = table.concat(virtual_string, "", index + 1, index + space_count)
+                        end
+                    else
+                        if table.maxn(virtual_string) >= index + space_count - 1 then
+                            tmp_string = table.concat(virtual_string, "", index, index + space_count - 1)
+                        end
+                    end
+                    table.insert(virtual_text, {
+                        utils._if(
+                            tmp_string,
+                            tmp_string,
+                            utils._if(blankline, space_char_blankline, list_chars["lead_char"]):rep(space_count)
+                        ),
+                        utils._if(
+                            blankline,
+                            utils.get_from_list(space_char_blankline_highlight_list, i, space_char_blankline_highlight),
+                            utils.get_from_list(
+                                space_char_highlight_list,
+                                i,
+                                utils._if(context, context_space_char_highlight, space_char_highlight)
+                            )
+                        ),
+                    })
+                end
+            end
+
+            local index = math.ceil(#virtual_text / 2) + 1
+            local extra_context_active = context_active and context_indent == index
+
+            if
+                (
+                    (indent_char ~= "" or #indent_char_list > 0)
+                    or (extra_context_active and (context_indent_char ~= "" or #context_char_list > 0))
+                )
+                and ((blankline or extra) and trail_indent)
+                and (first_indent or #virtual_text > 0)
+                and current_left_offset < 1
+                and indent < local_max_indent_level
+            then
+                table.insert(virtual_text, {
+                    utils._if(
+                        extra_context_active,
+                        utils.get_from_list(
+                            context_indent_char_list,
+                            index - utils._if(not first_indent, 1, 0),
+                            context_indent_char
+                        ),
+                        utils.get_from_list(indent_char_list, index - utils._if(not first_indent, 1, 0), indent_char)
+                    ),
+                    utils._if(
+                        extra_context_active,
+                        utils.get_from_list(context_highlight_list, index, context_highlight),
+                        utils.get_from_list(char_highlight_list, index, char_highlight)
+                    ),
+                })
+            end
+
+            return virtual_text
+        end
+
+    local prev_indent
+    local next_indent
+    local next_extra
+    local empty_line_counter = 0
+    local context_indent
+    for i = 1, #lines do
+        if foldtext and vim.fn.foldclosed(i + offset) > 0 then
+            utils.clear_line_indent(bufnr, i + offset)
+        else
+            local async
+            async = vim.loop.new_async(function()
+                local blankline = lines[i]:len() == 0
+                local whitespace = string.match(lines[i], "^%s+") or ""
+                local only_whitespace = whitespace == lines[i]
+                local context_active = false
+                local context_first_line = false
+                if context_status then
+                    context_active = offset + i > context_start and offset + i <= context_end
+                    context_first_line = offset + i == context_start
+                end
+
+                if blankline and use_ts_indent then
+                    vim.schedule_wrap(function()
+                        local indent = ts_indent.get_indent(i + offset) or 0
+                        utils.clear_line_indent(bufnr, i + offset)
+
+                        if
+                            context_first_line
+                            and show_current_context_start
+                            and (show_current_context_start_on_current_line or lnum ~= context_start)
+                        then
+                            if
+                                not vim.api.nvim_buf_is_loaded(bufnr)
+                                or not vim.api.nvim_buf_get_var(bufnr, "__indent_blankline_active")
+                            then
+                                return
+                            end
+                            xpcall(
+                                vim.api.nvim_buf_set_extmark,
+                                utils.error_handler,
+                                bufnr,
+                                vim.g.indent_blankline_namespace,
+                                context_start - 1,
+                                #whitespace,
+                                {
+                                    end_col = #lines[i],
+                                    hl_group = "IndentBlanklineContextStart",
+                                    priority = context_start_priority,
+                                }
+                            )
+                        end
+
+                        if indent == 0 then
+                            return
+                        end
+
+                        indent = indent / shiftwidth
+                        if context_first_line then
+                            context_indent = indent + 1
+                        end
+
+                        local virtual_text = get_virtual_text(
+                            indent,
+                            false,
+                            blankline,
+                            context_active,
+                            context_indent,
+                            max_indent_level,
+                            {}
+                        )
+                        if
+                            not vim.api.nvim_buf_is_loaded(bufnr)
+                            or not vim.api.nvim_buf_get_var(bufnr, "__indent_blankline_active")
+                        then
+                            return
+                        end
+                        xpcall(
+                            vim.api.nvim_buf_set_extmark,
+                            utils.error_handler,
+                            bufnr,
+                            vim.g.indent_blankline_namespace,
+                            i - 1 + offset,
+                            0,
+                            {
+                                virt_text = virtual_text,
+                                virt_text_pos = "overlay",
+                                hl_mode = "combine",
+                                priority = char_priority,
+                            }
+                        )
+                    end)()
+                    return async:close()
+                end
+
+                local indent, extra
+                local virtual_string = {}
+                if not blankline then
+                    indent, extra, virtual_string =
+                        utils.find_indent(whitespace, only_whitespace, shiftwidth, strict_tabs, list_chars)
+                elseif empty_line_counter > 0 then
+                    empty_line_counter = empty_line_counter - 1
+                    indent = next_indent
+                    extra = next_extra
+                else
+                    if i == #lines then
+                        indent = 0
+                        extra = false
+                    else
+                        local j = i + 1
+                        while j < #lines and lines[j]:len() == 0 do
+                            j = j + 1
+                            empty_line_counter = empty_line_counter + 1
+                        end
+                        local j_whitespace = string.match(lines[j], "^%s+")
+                        local j_only_whitespace = j_whitespace == lines[j]
+                        indent, extra, _ =
+                            utils.find_indent(j_whitespace, j_only_whitespace, shiftwidth, strict_tabs, list_chars)
+                    end
+                    next_indent = indent
+                    next_extra = extra
+                end
+
+                if context_first_line then
+                    context_indent = indent + 1
+                end
+
+                vim.schedule_wrap(utils.clear_line_indent)(bufnr, i + offset)
+                if
+                    context_first_line
+                    and show_current_context_start
+                    and (show_current_context_start_on_current_line or lnum ~= context_start)
+                then
+                    vim.schedule_wrap(function()
+                        if
+                            not vim.api.nvim_buf_is_loaded(bufnr)
+                            or not vim.api.nvim_buf_get_var(bufnr, "__indent_blankline_active")
+                        then
+                            return
+                        end
+                        xpcall(
+                            vim.api.nvim_buf_set_extmark,
+                            utils.error_handler,
+                            bufnr,
+                            vim.g.indent_blankline_namespace,
+                            context_start - 1,
+                            #whitespace,
+                            {
+                                end_col = #lines[i],
+                                hl_group = "IndentBlanklineContextStart",
+                                priority = context_start_priority,
+                            }
+                        )
+                    end)()
+                end
+
+                if indent == 0 and #virtual_string == 0 and not extra then
+                    prev_indent = 0
+                    return async:close()
+                end
+
+                if not prev_indent or indent + utils._if(extra, 1, 0) <= prev_indent + max_indent_increase then
+                    prev_indent = indent
+                end
+
+                local virtual_text = get_virtual_text(
+                    indent,
+                    extra,
+                    blankline,
+                    context_active,
+                    context_indent,
+                    prev_indent - utils._if(trail_indent, 0, 1),
+                    virtual_string
+                )
+                vim.schedule_wrap(function()
+                    if
+                        not vim.api.nvim_buf_is_loaded(bufnr)
+                        or not vim.api.nvim_buf_get_var(bufnr, "__indent_blankline_active")
+                    then
+                        return
+                    end
+                    xpcall(
+                        vim.api.nvim_buf_set_extmark,
+                        utils.error_handler,
+                        bufnr,
+                        vim.g.indent_blankline_namespace,
+                        i - 1 + offset,
+                        0,
+                        {
+                            virt_text = virtual_text,
+                            virt_text_pos = "overlay",
+                            hl_mode = "combine",
+                            priority = char_priority,
+                        }
+                    )
+                end)()
+                return async:close()
+            end)
+
+            async:send()
+        end
+    end
+end
+
+M.refresh = function(scroll)
+    xpcall(refresh, utils.error_handler, scroll)
+end
+
+return M
diff --git a/start/indent-blankline-2.20.4/lua/indent_blankline/utils.lua b/start/indent-blankline-2.20.4/lua/indent_blankline/utils.lua
new file mode 100644
index 0000000..e21a5c9
--- /dev/null
+++ b/start/indent-blankline-2.20.4/lua/indent_blankline/utils.lua
@@ -0,0 +1,341 @@
+local M = {}
+
+M.memo = setmetatable({
+    put = function(cache, params, result)
+        local node = cache
+        for i = 1, #params do
+            local param = vim.inspect(params[i])
+            node.children = node.children or {}
+            node.children[param] = node.children[param] or {}
+            node = node.children[param]
+        end
+        node.result = result
+    end,
+    get = function(cache, params)
+        local node = cache
+        for i = 1, #params do
+            local param = vim.inspect(params[i])
+            node = node.children and node.children[param]
+            if not node then
+                return nil
+            end
+        end
+        return node.result
+    end,
+}, {
+    __call = function(memo, func)
+        local cache = {}
+
+        return function(...)
+            local params = { ... }
+            local result = memo.get(cache, params)
+            if not result then
+                result = { func(...) }
+                memo.put(cache, params, result)
+            end
+            return unpack(result)
+        end
+    end,
+})
+
+M.error_handler = function(err, level)
+    if err:match "Invalid buffer id.*" then
+        return
+    end
+    if not pcall(require, "notify") then
+        err = string.format("indent-blankline: %s", err)
+    end
+    vim.notify_once(err, level or vim.log.levels.DEBUG, {
+        title = "indent-blankline",
+    })
+end
+
+M.is_indent_blankline_enabled = M.memo(
+    function(
+        b_enabled,
+        g_enabled,
+        disable_with_nolist,
+        opt_list,
+        filetype,
+        filetype_include,
+        filetype_exclude,
+        buftype,
+        buftype_exclude,
+        bufname_exclude,
+        bufname
+    )
+        if b_enabled ~= nil then
+            return b_enabled
+        end
+        if g_enabled ~= true then
+            return false
+        end
+        if disable_with_nolist and not opt_list then
+            return false
+        end
+
+        local plain = M._if(vim.fn.has "nvim-0.6.0" == 1, { plain = true }, true)
+        local undotted_filetypes = vim.split(filetype, ".", plain)
+        table.insert(undotted_filetypes, filetype)
+
+        for _, ft in ipairs(filetype_exclude) do
+            for _, undotted_filetype in ipairs(undotted_filetypes) do
+                if undotted_filetype == ft then
+                    return false
+                end
+            end
+        end
+
+        for _, bt in ipairs(buftype_exclude) do
+            if bt == buftype then
+                return false
+            end
+        end
+
+        for _, bn in ipairs(bufname_exclude) do
+            if vim.fn["matchstr"](bufname, bn) == bufname then
+                return false
+            end
+        end
+
+        if #filetype_include > 0 then
+            for _, ft in ipairs(filetype_include) do
+                if ft == filetype then
+                    return true
+                end
+            end
+            return false
+        end
+
+        return true
+    end
+)
+
+M.clear_line_indent = function(buf, lnum)
+    xpcall(vim.api.nvim_buf_clear_namespace, M.error_handler, buf, vim.g.indent_blankline_namespace, lnum - 1, lnum)
+end
+
+M.clear_buf_indent = function(buf)
+    xpcall(vim.api.nvim_buf_clear_namespace, M.error_handler, buf, vim.g.indent_blankline_namespace, 0, -1)
+end
+
+M.get_from_list = function(list, i, default)
+    if not list or #list == 0 then
+        return default
+    end
+    return list[((i - 1) % #list) + 1]
+end
+
+M._if = function(bool, a, b)
+    if bool then
+        return a
+    else
+        return b
+    end
+end
+
+M.find_indent = function(whitespace, only_whitespace, shiftwidth, strict_tabs, list_chars)
+    local indent = 0
+    local spaces = 0
+    local tab_width
+    local virtual_string = {}
+
+    if whitespace then
+        for ch in whitespace:gmatch "." do
+            if ch == "\t" then
+                if strict_tabs and indent == 0 and spaces ~= 0 then
+                    return 0, false, {}
+                end
+                indent = indent + math.floor(spaces / shiftwidth) + 1
+                spaces = 0
+                -- replace dynamic-width tab with fixed-width string (ta..ab)
+                tab_width = shiftwidth - table.maxn(virtual_string) % shiftwidth
+                -- check if tab_char_end is set, see :help listchars
+                if list_chars["tab_char_end"] then
+                    if tab_width == 1 then
+                        table.insert(virtual_string, list_chars["tab_char_end"])
+                    else
+                        table.insert(virtual_string, list_chars["tab_char_start"])
+                        for _ = 1, (tab_width - 2) do
+                            table.insert(virtual_string, list_chars["tab_char_fill"])
+                        end
+                        table.insert(virtual_string, list_chars["tab_char_end"])
+                    end
+                else
+                    table.insert(virtual_string, list_chars["tab_char_start"])
+                    for _ = 1, (tab_width - 1) do
+                        table.insert(virtual_string, list_chars["tab_char_fill"])
+                    end
+                end
+            else
+                if strict_tabs and indent ~= 0 then
+                    -- return early when no more tabs are found
+                    return indent, true, virtual_string
+                end
+                if only_whitespace then
+                    -- if the entire line is only whitespace use trail_char instead of lead_char
+                    table.insert(virtual_string, list_chars["trail_char"])
+                else
+                    table.insert(virtual_string, list_chars["lead_char"])
+                end
+                spaces = spaces + 1
+            end
+        end
+    end
+
+    return indent + math.floor(spaces / shiftwidth), table.maxn(virtual_string) % shiftwidth ~= 0, virtual_string
+end
+
+M.get_current_context = function(type_patterns, use_treesitter_scope)
+    local ts_utils_status, ts_utils = pcall(require, "nvim-treesitter.ts_utils")
+    if not ts_utils_status then
+        vim.schedule_wrap(function()
+            M.error_handler("nvim-treesitter not found. Context will not work", vim.log.levels.WARN)
+        end)()
+        return false
+    end
+    local locals = require "nvim-treesitter.locals"
+    local cursor_node = ts_utils.get_node_at_cursor()
+
+    if use_treesitter_scope then
+        local current_scope = locals.containing_scope(cursor_node, 0)
+        if not current_scope then
+            return false
+        end
+        local node_start, _, node_end, _ = current_scope:range()
+        if node_start == node_end then
+            return false
+        end
+        return true, node_start + 1, node_end + 1, current_scope:type()
+    end
+
+    while cursor_node do
+        local node_type = cursor_node:type()
+        for _, rgx in ipairs(type_patterns) do
+            if node_type:find(rgx) then
+                local node_start, _, node_end, _ = cursor_node:range()
+                if node_start ~= node_end then
+                    return true, node_start + 1, node_end + 1, rgx
+                end
+            end
+        end
+        cursor_node = cursor_node:parent()
+    end
+
+    return false
+end
+
+M.reset_highlights = function()
+    local whitespace_highlight = vim.fn.synIDtrans(vim.fn.hlID "Whitespace")
+    local label_highlight = vim.fn.synIDtrans(vim.fn.hlID "Label")
+
+    local whitespace_fg = {
+        vim.fn.synIDattr(whitespace_highlight, "fg", "gui"),
+        vim.fn.synIDattr(whitespace_highlight, "fg", "cterm"),
+    }
+    local label_fg = {
+        vim.fn.synIDattr(label_highlight, "fg", "gui"),
+        vim.fn.synIDattr(label_highlight, "fg", "cterm"),
+    }
+
+    for highlight_name, highlight in pairs {
+        IndentBlanklineChar = whitespace_fg,
+        IndentBlanklineSpaceChar = whitespace_fg,
+        IndentBlanklineSpaceCharBlankline = whitespace_fg,
+        IndentBlanklineContextChar = label_fg,
+        IndentBlanklineContextStart = label_fg,
+    } do
+        local current_highlight = vim.fn.synIDtrans(vim.fn.hlID(highlight_name))
+        if
+            vim.fn.synIDattr(current_highlight, "fg") == ""
+            and vim.fn.synIDattr(current_highlight, "bg") == ""
+            and vim.fn.synIDattr(current_highlight, "sp") == ""
+        then
+            if highlight_name == "IndentBlanklineContextStart" then
+                vim.cmd(
+                    string.format(
+                        "highlight %s guisp=%s gui=underline cterm=underline",
+                        highlight_name,
+                        M._if(highlight[1] == "", "NONE", highlight[1])
+                    )
+                )
+            else
+                vim.cmd(
+                    string.format(
+                        "highlight %s guifg=%s ctermfg=%s gui=nocombine cterm=nocombine",
+                        highlight_name,
+                        M._if(highlight[1] == "", "NONE", highlight[1]),
+                        M._if(highlight[2] == "", "NONE", highlight[2])
+                    )
+                )
+            end
+        end
+    end
+end
+
+M.first_not_nil = function(...)
+    for _, value in pairs { ... } do -- luacheck: ignore
+        return value
+    end
+end
+
+M.get_variable = function(key)
+    if vim.b[key] ~= nil then
+        return vim.b[key]
+    end
+    if vim.t[key] ~= nil then
+        return vim.t[key]
+    end
+    return vim.g[key]
+end
+
+M.merge_ranges = function(ranges)
+    local merged_ranges = { { unpack(ranges[1]) } }
+
+    for i = 2, #ranges do
+        local current_end = merged_ranges[#merged_ranges][2]
+        local next_start, next_end = unpack(ranges[i])
+        if current_end >= next_start - 1 then
+            if current_end < next_end then
+                merged_ranges[#merged_ranges][2] = next_end
+            end
+        else
+            table.insert(merged_ranges, { next_start, next_end })
+        end
+    end
+
+    return merged_ranges
+end
+
+M.binary_search_ranges = function(ranges, target_range)
+    local exact_match = false
+    local idx_start = 1
+    local idx_end = #ranges
+    local idx_mid
+
+    local range_start
+    local target_start = target_range[1]
+
+    while idx_start < idx_end do
+        idx_mid = math.ceil((idx_start + idx_end) / 2)
+        range_start = ranges[idx_mid][1]
+
+        if range_start == target_start then
+            exact_match = true
+            break
+        elseif range_start < target_start then
+            idx_start = idx_mid -- it's important to make the low-end inclusive
+        else
+            idx_end = idx_mid - 1
+        end
+    end
+
+    -- if we don't have an exact match, choose the smallest index
+    if not exact_match then
+        idx_mid = idx_start
+    end
+
+    return idx_mid
+end
+
+return M
diff --git a/start/indent-blankline-2.20.4/plugin/indent_blankline.vim b/start/indent-blankline-2.20.4/plugin/indent_blankline.vim
new file mode 100644
index 0000000..203d140
--- /dev/null
+++ b/start/indent-blankline-2.20.4/plugin/indent_blankline.vim
@@ -0,0 +1,41 @@
+
+if exists('g:loaded_indent_blankline') || !has('nvim-0.5.0')
+    finish
+endif
+let g:loaded_indent_blankline = 1
+
+function s:try(cmd)
+    try
+        execute a:cmd
+    catch /E12/
+        return
+    endtry
+endfunction
+
+command! -bang IndentBlanklineRefresh call s:try('lua require("indent_blankline.commands").refresh("<bang>" == "!")')
+command! -bang IndentBlanklineRefreshScroll call s:try('lua require("indent_blankline.commands").refresh("<bang>" == "!", true)')
+command! -bang IndentBlanklineEnable call s:try('lua require("indent_blankline.commands").enable("<bang>" == "!")')
+command! -bang IndentBlanklineDisable call s:try('lua require("indent_blankline.commands").disable("<bang>" == "!")')
+command! -bang IndentBlanklineToggle call s:try('lua require("indent_blankline.commands").toggle("<bang>" == "!")')
+
+if exists(':IndentLinesEnable') && !g:indent_blankline_disable_warning_message
+    echohl Error
+    echom 'indent-blankline does not require IndentLine anymore, please remove it.'
+    echohl None
+endif
+
+if !exists('g:__indent_blankline_setup_completed')
+    lua require("indent_blankline").setup {}
+endif
+
+lua require("indent_blankline").init()
+
+augroup IndentBlanklineAutogroup
+    autocmd!
+    autocmd OptionSet list,listchars,shiftwidth,tabstop,expandtab IndentBlanklineRefresh
+    autocmd FileChangedShellPost,TextChanged,TextChangedI,CompleteChanged,BufWinEnter,Filetype * IndentBlanklineRefresh
+    autocmd WinScrolled * IndentBlanklineRefreshScroll
+    autocmd ColorScheme * lua require("indent_blankline.utils").reset_highlights()
+    autocmd VimEnter * lua require("indent_blankline").init()
+augroup END
+