diff --git a/home/common/ghidra-stdcall.patch b/home/common/ghidra-stdcall.patch new file mode 100644 index 0000000..5ddb0cd --- /dev/null +++ b/home/common/ghidra-stdcall.patch @@ -0,0 +1,45 @@ +diff --git a/Ghidra/Processors/x86/data/languages/x86gcc.cspec b/Ghidra/Processors/x86/data/languages/x86gcc.cspec +index 17448cf9..b115b957 100644 +--- a/Ghidra/Processors/x86/data/languages/x86gcc.cspec ++++ b/Ghidra/Processors/x86/data/languages/x86gcc.cspec +@@ -286,6 +286,40 @@ + + + ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ + + + diff --git a/home/common/nvim/default.nix b/home/common/nvim/default.nix new file mode 100644 index 0000000..ed1c389 --- /dev/null +++ b/home/common/nvim/default.nix @@ -0,0 +1,585 @@ +{ config, pkgs, lib, ... }: +{ + imports = [ ../options.nix ]; + /* + VIM config backup: + syntax on + au FileType markdown set colorcolumn=73 textwidth=72 + au FileType gitcommit set colorcolumn=73 + highlight NormalFloat guibg=NONE + au BufReadPre * set foldmethod=syntax + au BufReadPost * folddoc foldopen! + autocmd BufReadPost * if @% !~# '\.git[\/\\]COMMIT_EDITMSG$' && line("'\"") > 1 && line("'\"") <= line("$") | exe "normal! g`\"" | endif + */ + programs.neovim = let + # a cursed DSL + identLines = lines: builtins.concatStringsSep "\n" (map (x: " ${x}") lines); + ident = code: identLines (lib.splitString "\n" code); + # probably not the best heuristics, but good enough to make the output readable + wrapSafe = s: (builtins.match "^[-\"a-zA-Z0-9_.()]*$" s) != null; + wrapExpr = s: if wrapSafe s then s else "(${s})"; + keySafe = s: (builtins.match "^[a-zA-Z_][_a-zA-Z0-9]*$" s) != null; + wrapKey = scope: s: if keySafe s then s else "[${compileExpr scope s}]"; + compileFunc' = argn: sc@{sname,scope}: id: func: + (if builtins.isFunction func + then + (compileFunc' + (argn + 1) + sc + id + (func (let + args = builtins.functionArgs func; + rawVar = var "${sname}_${id}_arg${builtins.toString (scope + argn)}"; + in if args == {} + then rawVar + else builtins.mapAttrs (k: v: prop rawVar k) args + ))) + else '' + function ${id}(${builtins.concatStringsSep ", " (builtins.genList (n: "${sname}_${id}_arg${builtins.toString (scope + n)}") argn)}) + ${ident (compileStmt {inherit sname;scope = scope + argn;} func)} + end''); + compileFunc = compileFunc' 0; + compileExpr = sc: func: ( + if builtins.isString func then + if lib.hasInfix "\n" func then '' + [[ + ${ident func} + ]]'' else "\"${lib.escape ["\\" "\""] func}\"" + else if builtins.isInt func then builtins.toString func + else if builtins.isFloat func then builtins.toString func + else if builtins.isBool func then (if func then "true" else "false") + else if builtins.isNull func then "nil" + else if builtins.isPath func then compileExpr sc (builtins.toString func) + else if builtins.isFunction func then let + info = if builtins.functionArgs func == {} then (func "GET_INFO") else null; in + if builtins.isAttrs info && info?value + then info.value + else (compileFunc sc "" func) + else if builtins.isList func then '' + { + ${ident (builtins.concatStringsSep "\n" (map (x: (compileExpr sc x) + ";" ) func))} + }'' + else if builtins.isAttrs func && !(func?__kind) then '' + { + ${ident (builtins.concatStringsSep "\n" (lib.mapAttrsToList (k: v: "${wrapKey sc k} = ${compileExpr sc v};") func))} + }'' + else if func.__kind == "var" then + "${func._name}" + else if func.__kind == "op2" then + builtins.concatStringsSep func.op (map (x: wrapExpr (compileExpr sc x)) func.args) + else if func.__kind == "defun" then + (compileFunc sc (if func?id then func.id else "") func.func) + else if func.__kind == "prop" then + "${wrapExpr (compileExpr sc func.expr)}.${func.name}" + else if func.__kind == "call" then + "${wrapExpr (compileExpr sc func.func)}(${builtins.concatStringsSep ", " (map (compileExpr sc) (if builtins.isList func.args then func.args else [func.args]))})" + else if func.__kind == "mcall" then + "${wrapExpr (compileExpr sc func.val)}:${func.name}(${builtins.concatStringsSep ", " (map (compileExpr sc) (if builtins.isList func.args then func.args else [func.args]))})" + else if func.__kind == "tableAttr" then + "${wrapExpr (compileExpr sc func.table)}[${compileExpr sc func.key}]" + else null + ); + compileStmt = sc@{sname,scope}: func: ( + if builtins.isList func then builtins.concatStringsSep "\n" (map (compileStmt sc) func) + else if builtins.isAttrs func && (func?__kind) then ( + if func.__kind == "assign" then + "${compileExpr sc func.expr} = ${compileExpr sc func.val}" + else if func.__kind == "bind" then + "local ${func.name} = ${compileExpr sc func.val}" + else if func.__kind == "let" then '' + ${builtins.concatStringsSep "\n" (lib.imap0 (n: val: + "local ${sname}_var${builtins.toString (scope + n)} = ${ + compileExpr sc val + }") func.vals)} + ${let vals = func.vals; origScope = scope; apply = { scope, func }: if scope == (origScope + (builtins.length vals)) then func else apply { + scope = scope + 1; + func = func (raw "${sname}_var${builtins.toString scope}"); + }; in + compileStmt {inherit sname;scope = scope + (builtins.length func.vals);} (apply { inherit scope; inherit (func) func; }) + }'' + else if func.__kind == "letrec" then '' + ${builtins.concatStringsSep "\n" (lib.imap0 (n: val: + "local ${sname}_var${builtins.toString (scope + n)} = ${ + let vals = func.vals; origScope = scope; apply = { scope, func }: if scope == (origScope + (builtins.length vals)) then func else apply { + scope = scope + 1; + func = func (raw "${sname}_var${builtins.toString scope}"); + }; in + compileExpr {inherit sname;scope = scope + (builtins.length func.vals);} (apply { inherit scope; func = val; }) + }") func.vals)} + ${let vals = func.vals; origScope = scope; apply = { scope, func }: if scope == (origScope + (builtins.length vals)) then func else apply { + scope = scope + 1; + func = func (raw "${sname}_var${builtins.toString scope}"); + }; in + compileStmt {inherit sname;scope = scope + (builtins.length func.vals);} (apply { inherit scope; inherit (func) func; }) + }'' + else if func.__kind == "for" then let + varNames = builtins.genList (n: "${sname}_var${builtins.toString (scope + n)}") func.n; + scope' = { inherit sname; scope = scope + 1; }; + in '' + for ${builtins.concatStringsSep "," varNames} in ${compileExpr scope' func.expr} do + ${ + let argn = func.n; origScope = scope; apply = { scope, func }: if scope == (origScope + argn) then func else apply { + scope = scope + 1; + func = func (raw "${sname}_var${builtins.toString scope}"); + }; in + ident (compileStmt scope' (apply { inherit scope; func = func.body; })) + } + end'' + else if func.__kind == "return" then + "return ${compileExpr sc func.expr}" + else if func.__kind == "if" then + (lib.removeSuffix "else" ((builtins.concatStringsSep "" (map + (cond: '' + if ${compileExpr sc (builtins.elemAt cond 0)} then + ${ident (compileStmt sc (builtins.elemAt cond 1))} + else'') + func.conds)) + + (if func.fallback != null then "\n${ident (compileStmt sc func.fallback)}\n" else ""))) + "end" + else compileExpr sc func + ) else compileExpr sc func + ); + compile = sname: compileStmt {inherit sname;scope=1;}; + var = name: { __kind = "var"; _name = name; }; + raw = var; + prop = expr: name: { __kind = "prop"; inherit expr name; }; + call = func: args: { __kind = "call"; inherit func args; }; + mcall = val: name: args: { __kind = "mcall"; inherit val name args; }; + setup = plugin: opts: call (prop plugin "setup") [ opts ]; + require = name: call (var "require") [ name ]; + set = expr: val: { __kind = "assign"; inherit expr val; }; + op2 = op: args: + if builtins.isList args then { __kind = "op2"; inherit op args; } + else (secondArg: { __kind = "op2"; inherit op; args = [ args secondArg ]; }) + ; + eq = op2 "=="; + # forin = n: expr: body: { __kind = "for"; inherit n expr body; }; + # gt = op2 ">"; + # ge = op2 ">="; + # ne = op2 "~="; + # and = op2 "and"; + # or = op2 "or"; + return = expr: { __kind = "return"; inherit expr; }; + defun = func: { __kind = "defun"; inherit func; }; + ifelse = conds: fallback: { __kind = "if"; inherit fallback; conds = if builtins.isList (builtins.elemAt conds 0) then conds else [conds]; }; + # ifnoelse = conds: ifelse conds null; + tableAttr = table: key: { __kind = "tableAttr"; inherit table key; }; + bind = vals: func: if builtins.isList vals then { __kind = "let"; inherit vals func; } else bind [ vals ] func; + bindrec = vals: func: if builtins.isList vals then { __kind = "letrec"; inherit vals func; } else bindrec [ vals ] func; + defs = pkgs.callPackage ./vim-opts.nix { inherit raw call; }; + in with defs; let + # bind' = name: val: { __kind = "bind"; inherit name val; }; + # vimfn = name: call (raw "vim.fn.${name}"); + vimcmd = name: call (raw "vim.cmd.${name}"); + keymapSetSingle = opts@{ + mode, + lhs, + rhs, + noremap ? true, + silent ? true, + ... + }: let + opts''' = opts // { inherit noremap silent; }; + opts' = lib.filterAttrs (k: v: + k != "keys" && k != "mode" && k != "lhs" && k != "rhs" && k != "desc" + # defaults to false + && ((k != "silent" && k != "noremap") || (builtins.isBool v && v))) opts'''; + in vim.keymap.set [ mode lhs rhs opts' ]; + keymapSetMulti = opts@{ + keys, + mode, + noremap ? true, + silent ? true, + ... + }: let + opts'' = opts // { inherit noremap silent; }; + opts' = lib.filterAttrs (k: v: + k != "keys" && k != "lhs" && k != "rhs" && k != "desc" + # defaults to false + && ((k != "silent" && k != "noremap") || (builtins.isBool v && v))) opts''; + in (lib.mapAttrsToList (k: {rhs, desc}: keymapSetSingle (opts' // { + lhs = k; inherit rhs; + })) keys) ++ [ + (call (prop (require "which-key") "register") [(lib.mapAttrs (k: v: [v.rhs v.desc]) keys) opts']) + ]; + keymapSetN = args: keymapSetSingle (args // { mode = "n"; }); + keymapSetV = args: keymapSetSingle (args // { mode = "v"; }); + keymapSetNs = args: keymapSetMulti (args // { mode = "n"; }); + kmSetNs = keys: keymapSetNs { inherit keys; }; + in { + enable = true; + defaultEditor = true; + package = pkgs.neovim-unwrapped; + extraPackages = with pkgs; [ + rust-analyzer + nodePackages_latest.bash-language-server shellcheck + nodePackages_latest.typescript-language-server + nodePackages_latest.svelte-language-server + clang-tools + nodePackages_latest.vscode-langservers-extracted + nil + marksman + taplo + (python3.withPackages (p: with p; [ + python-lsp-server + pylsp-mypy + python-lsp-server.optional-dependencies.pyflakes + python-lsp-server.optional-dependencies.mccabe + python-lsp-server.optional-dependencies.pycodestyle + ])) + ]; + # extraPython3Packages = pyPkgs: with pyPkgs; [ + # ]; + extraLuaConfig = (compile "main" [ + (set vim.g.vimsyn_embed "l") + (vim.api.nvim_set_hl [ 0 "NormalFloat" { + bg = "NONE"; + }]) + (bind (vim.api.nvim_create_augroup [ "nvimrc" { clear = true; } ]) (group: + map (au: let au' = lib.filterAttrs (k: v: k != "event") au; + in vim.api.nvim_create_autocmd [ au.event ({ + inherit group; + } // au') ] + ) [ + { event = "FileType"; + pattern = ["markdown" "gitcommit"]; + callback = defun (set vim.o.colorcolumn 73); } + { event = "FileType"; + pattern = ["markdown"]; + callback = defun (set vim.o.textwidth 72); } + { event = "BufReadPre"; + inherit group; + callback = defun (set vim.o.foldmethod "syntax"); } + { event = "BufWinEnter"; + inherit group; + callback = { buf, ... }: + (bind (vim.filetype.match { inherit buf; }) (filetype: [ + (vimcmd "folddoc" [ "foldopen!" ]) + (ifelse [(eq filetype "gitcommit") [ + (vim.cmd { + cmd = "normal"; + bang = true; + args = [ "gg" ]; + }) + ]] + (vim.cmd { + cmd = "normal"; + bang = true; + args = [ "g`\"" ]; + }) + ) + ])); } + ])) # END + ]); + viAlias = true; + vimAlias = true; + vimdiffAlias = true; + plugins = with pkgs.vimPlugins; map (x: if x?config && x?plugin then { type = "lua"; } // x else x) [ + vim-svelte + # TODO remove on next nvim update (0.8.3/0.9) + vim-nix + { plugin = pkgs.vimUtils.buildVimPluginFrom2Nix { + pname = "vscode-nvim"; + version = "2023-02-10"; + src = pkgs.fetchFromGitHub { + owner = "Mofiqul"; + repo = "vscode.nvim"; + rev = "db9ee339b5556aa832ca58871fd18f9467a18520"; + sha256 = "sha256-X2IgIjO5NNq7vJdl09hBY1TFqHlsfF1xfllKr4osILI="; + }; + }; + config = compile "vscode_nvim" (setup (require "vscode") { + transparent = true; + color_overrides = { + vscGray = "#745b5f"; + vscViolet = "#${config.colors.magenta}"; + vscBlue = "#6ddfd8"; + vscDarkBlue = "#${config.colors.blue}"; + vscGreen = "#${config.colors.green}"; + vscBlueGreen = "#73bf88"; + vscLightGreen = "#6acf6e"; + vscRed = "#${config.colors.red}"; + vscOrange = "#e89666"; + vscLightRed = "#e64e4e"; + vscYellowOrange = "#e8b166"; + vscYellow = "#${config.colors.yellow}"; + vscPink = "#cf83c4"; + }; + }); } + # ''; } + { plugin = nvim-web-devicons; + config = compile "nvim_web_devicons" (setup (require "nvim-web-devicons") {}); } + { plugin = nvim-tree-lua; + config = compile "nvim_tree_lua" [ + (set vim.g.loaded_netrw 1) + (set vim.g.loaded_netrwPlugin 1) + (set vim.opt.termguicolors true) + (setup (require "nvim-tree") {}) # :help nvim-tree-setup + (keymapSetN { + lhs = ""; + rhs = prop (require "nvim-tree.api") "tree.toggle"; + desc = "Toggle NvimTree"; + }) + ]; } + vim-sleuth + luasnip + { plugin = nvim-cmp; + config = let + border = (name: [ + [ "╭" name ] + [ "─" name ] + [ "╮" name ] + [ "│" name ] + [ "╯" name ] + [ "─" name ] + [ "╰" name ] + [ "│" name ] + ]); + in compile "nvim_cmp" [(bind (require "cmp") (cmp: + (setup cmp { + snippet = { + expand = args: (call (prop (require "luasnip") "lsp_expand") (prop args "body")); + }; + view = { }; + window = { + completion = { + border = border "CmpBorder"; + winhighlight = "Normal:CmpPmenu,CursorLine:PmenuSel,Search:None"; + }; + documentation = { + border = border "CmpDocBorder"; + }; + }; + formatting = { + format = _: vim_item: [ + (set + (prop vim_item "kind") + (string.format (let kind = prop vim_item "kind"; in [ + "%s %s" + (tableAttr (require "lspkind") kind) + kind + ]))) + (return vim_item) + ]; + }; + mapping = { + "" = call (prop cmp "mapping.select_prev_item") []; + "" = call (prop cmp "mapping.select_next_item") []; + "" = call (prop cmp "mapping.complete") []; + "" = call (prop cmp "mapping.close") []; + "" = call (prop cmp "mapping.confirm") { + behavior = prop cmp "ConfirmBehavior.Replace"; + select = false; + }; + "" = call (prop cmp "mapping") [(fallback: + (ifelse [ + [(call (prop cmp "visible") []) + # then + (call (prop cmp "select_next_item") [])] + [(call (prop (require "luasnip") "expand_or_jumpable") []) + # then + (vim.api.nvim_feedkeys [ + (vim.api.nvim_replace_termcodes [ "luasnip-expand-or-jump" true true true ]) + "" + false + ]) + ]] + # else + (call fallback []) + )) + [ "i" "s" ] + ]; + "" = call (prop cmp "mapping") [(fallback: + (ifelse [ + [(call (prop cmp "visible" ) []) + # then + (call (prop cmp "select_prev_item") [])] + [(call (prop (require "luasnip") "jumpable") [ (-1) ]) + # then + (vim.api.nvim_feedkeys [ + (vim.api.nvim_replace_termcodes [ "luasnip-jump-prev" true true true ]) + "" + false + ]) + ]] + # else + (call fallback []) + )) + [ "i" "s" ] + ]; + }; + sources = call (prop cmp "config.sources") [[ + { name = "nvim_lsp"; } + { name = "luasnip"; } + ]]; + }) + ))]; } + lspkind-nvim + cmp_luasnip + cmp-nvim-lsp + { plugin = nvim-autopairs; + config = compile "nvim_autopairs" (bind (require "nvim-autopairs.completion.cmp") (cmp_autopairs: [ + (setup (require "nvim-autopairs") { + disable_filetype = [ "TelescopePrompt" "vim" ]; + }) + (mcall (prop (require "cmp") "event") "on" [ + "confirm_done" + (call (prop cmp_autopairs "on_confirm_done") []) + ]) + ])); } + { plugin = comment-nvim; + config = compile "comment_nvim" [ + (setup (require "Comment") {}) + (keymapSetN { + lhs = "/"; + rhs = (prop (require "Comment.api") "toggle.linewise.current"); + desc = "Comment current line"; + }) + (keymapSetV { + lhs = "/"; + rhs = "lua require('Comment.api').toggle.linewise(vim.fn.visualmode())"; + desc = "Comment current line"; + }) + ]; } + { plugin = nvim-lspconfig; + config = compile "nvim_lspconfig" (let setupLsp = lsp: setup (prop (require "lspconfig") lsp); in [ + # See `:help vim.diagnostic.*` for documentation on any of the below functions + (kmSetNs { + "e" = { + rhs = vim.diagnostic.open_float; + desc = "Show diagnostics in a floating window."; + }; + "[d" = { + rhs = vim.diagnostic.goto_prev; + desc = "Move to the previous diagnostic in the current buffer."; + }; + "]d" = { + rhs = vim.diagnostic.goto_next; + desc = "Get the next diagnostic closest to the cursor position."; + }; + "q" = { + rhs = vim.diagnostic.setloclist; + desc = "Add buffer diagnostics to the location list."; + }; + }) + (bind [ + # LET on_attach + (client: bufnr: ([ + # Enable completion triggered by + (vim.api.nvim_buf_set_option [ bufnr "omnifunc" "v:lua.vim.lsp.omnifunc" ]) + # Mappings. + # See `:help vim.lsp.*` for documentation on any of the below functions + (kmSetNs { + "gD" = { + rhs = vim.lsp.buf.declaration; + desc = "Jumps to the declaration of the symbol under the cursor."; }; + "gd" = { + rhs = vim.lsp.buf.definition; + desc = "Jumps to the definition of the symbol under the cursor."; }; + "K" = { + rhs = vim.lsp.buf.hover; + desc = "Displays hover information about the symbol under the cursor in a floating window."; }; + "gi" = { + rhs = vim.lsp.buf.implementation; + desc = "Lists all the implementations for the symbol under the cursor in the quickfix window."; }; + "" = { + rhs = vim.lsp.buf.signature_help; + desc = "Displays signature information about the symbol under the cursor in a floating window."; }; + "wa" = { + rhs = vim.lsp.buf.add_workspace_folder; + desc = "Add a folder to the workspace folders."; }; + "wr" = { + rhs = vim.lsp.buf.remove_workspace_folder; + desc = "Remove a folder from the workspace folders."; }; + "wl" = { + rhs = (defun (print [ + (vim.inspect [(vim.lsp.buf.list_workspace_folders [])]) + ])); + desc = "List workspace folders."; }; + "D" = { + rhs = vim.lsp.buf.type_definition; + desc = "Jumps to the definition of the type of the symbol under the cursor."; }; + "rn" = { + rhs = vim.lsp.buf.rename; + desc = "Rename old_fname to new_fname"; }; + "ca" = { + rhs = vim.lsp.buf.code_action; + desc = "Selects a code action available at the current cursor position."; }; + "gr" = { + rhs = vim.lsp.buf.references; + desc = "Lists all the references to the symbol under the cursor in the quickfix window."; }; + "f" = { + rhs = (defun (vim.lsp.buf.format {async = true;})); + desc = "Formats a buffer."; }; + }) + ])) + # LET rust_settings + { rust-analyzer = { + assist.emitMustUse = true; + cargo.buildScripts.enable = true; + check.command = "clippy"; + procMacro.enable = true; + }; } + # LET capabilities + (vim.tbl_extend [ + "keep" + (vim.lsp.protocol.make_client_capabilities []) + (call (prop (require "cmp_nvim_lsp") "default_capabilities") []) + ]) + # BEGIN + ] (on_attach: rust_settings: capabilities: [ + (bindrec + # LETREC on_attach_rust + (on_attach_rust: client: bufnr: [ + (vim.api.nvim_create_user_command ["RustAndroid" (opts: [ + (setupLsp "rust_analyzer" { + on_attach = on_attach_rust; + inherit capabilities; + settings = vim.tbl_deep_extend [ + "keep" + { rust-analyzer.cargo.target = "x86_64-linux-android"; } + rust_settings + ]; + }) + ]) {}]) + (call on_attach [client bufnr]) + ]) + # BEGIN + (let lsp = { name, settings ? {} }: setupLsp name { + inherit on_attach capabilities settings; + }; in (on_attach_rust: [ + (vim.lsp.set_log_level "debug") + ] ++ [ + (map lsp [ + # see https://github.com/neovim/nvim-lspconfig/blob/master/doc/server_configurations.md + { name = "bashls"; } + { name = "clangd"; } + # https://github.com/python-lsp/python-lsp-server/blob/develop/CONFIGURATION.md + { name = "pylsp"; settings = { + pylsp.plugins.pylsp_mypy.enabled = true; + }; } + { name = "svelte"; } + { name = "html"; } + { name = "cssls"; } + { name = "tsserver"; } + { name = "jsonls"; } + { name = "nil_ls"; } + { name = "taplo"; } + { name = "marksman"; } + ]) + (setupLsp "rust_analyzer" { + on_attach = on_attach_rust; + settings = rust_settings; + inherit capabilities; + }) + ]))) # END + ])) # END + ]); } + { plugin = which-key-nvim; + config = compile "which_key_nvim" [ + (set vim.o.timeout true) + (set vim.o.timeoutlen 500) + (setup (require "which-key") {}) + ]; } + ]; + }; +} diff --git a/home/common/nvim/dump_nvim_globals.lua b/home/common/nvim/dump_nvim_globals.lua new file mode 100644 index 0000000..0174369 --- /dev/null +++ b/home/common/nvim/dump_nvim_globals.lua @@ -0,0 +1,39 @@ +-- globals.lua +-- list all global variables +-- :enew|pu=execute('luafile /path/to/file.lua') +-- list vim vars +-- :new | put! =getcompletion('*', 'var') +-- list events +-- :new | put! =getcompletion('*', 'event') +-- list options +-- :new | put! =getcompletion('*', 'option') + +local seen={} + +function dump(t,i) + seen[t]=true + local s={} + local n=0 + for k in pairs(t) do + n=n+1 s[n]=k + end + local p0 = "package.loaded." + local i1 = (i:sub(0, #p0) == p0) and i:sub(#p0+1) or i + local p1 = "package.preload." + local i2 = (i1:sub(0, #p1) == p1) and i1:sub(#p1+1) or i1 + for k,v in ipairs(s) do + local v0=t[v] + if type(v0)=="table" and not seen[v0] then + dump(v0,i1..v..".") + elseif v ~= "vim._meta" and v ~= "vim._init_packages" and v ~= "table.clear" and v ~= "table.new" and type(v0) == "function" and i:sub(0, #p1) == p1 then + dump(v0(),i2..v..".") + elseif type(v0) == "function" then + print("function/"..debug.getinfo(v0).nparams.."/"..i..v) + elseif type(v0) ~= "table" then + print(type(v0).."/"..i..v) + end + end +end + +dump(_G,"") + diff --git a/home/common/nvim/vim-events.txt b/home/common/nvim/vim-events.txt new file mode 100644 index 0000000..b0b3e55 --- /dev/null +++ b/home/common/nvim/vim-events.txt @@ -0,0 +1,128 @@ +BufAdd +BufCreate +BufDelete +BufEnter +BufFilePost +BufFilePre +BufHidden +BufLeave +BufModifiedSet +BufNew +BufNewFile +BufRead +BufReadCmd +BufReadPost +BufReadPre +BufUnload +BufWinEnter +BufWinLeave +BufWipeout +BufWrite +BufWriteCmd +BufWritePost +BufWritePre +ChanInfo +ChanOpen +CmdUndefined +CmdWinEnter +CmdWinLeave +CmdlineChanged +CmdlineEnter +CmdlineLeave +ColorScheme +ColorSchemePre +CompleteChanged +CompleteDone +CompleteDonePre +CursorHold +CursorHoldI +CursorMoved +CursorMovedI +DiagnosticChanged +DiffUpdated +DirChanged +DirChangedPre +EncodingChanged +ExitPre +FileAppendCmd +FileAppendPost +FileAppendPre +FileChangedRO +FileChangedShell +FileChangedShellPost +FileEncoding +FileReadCmd +FileReadPost +FileReadPre +FileType +FileWriteCmd +FileWritePost +FileWritePre +FilterReadPost +FilterReadPre +FilterWritePost +FilterWritePre +FocusGained +FocusLost +FuncUndefined +GUIEnter +GUIFailed +InsertChange +InsertCharPre +InsertEnter +InsertLeave +InsertLeavePre +LspAttach +LspDetach +MenuPopup +ModeChanged +OptionSet +QuickFixCmdPost +QuickFixCmdPre +QuitPre +RecordingEnter +RecordingLeave +RemoteReply +SearchWrapped +SessionLoadPost +ShellCmdPost +ShellFilterPost +Signal +SourceCmd +SourcePost +SourcePre +SpellFileMissing +StdinReadPost +StdinReadPre +SwapExists +Syntax +TabClosed +TabEnter +TabLeave +TabNew +TabNewEntered +TermChanged +TermClose +TermEnter +TermLeave +TermOpen +TermResponse +TextChanged +TextChangedI +TextChangedP +TextYankPost +UIEnter +UILeave +User +VimEnter +VimLeave +VimLeavePre +VimResized +VimResume +VimSuspend +WinClosed +WinEnter +WinLeave +WinNew +WinScrolled + diff --git a/home/common/nvim/vim-lua.txt b/home/common/nvim/vim-lua.txt new file mode 100644 index 0000000..2209b1f --- /dev/null +++ b/home/common/nvim/vim-lua.txt @@ -0,0 +1,9161 @@ +function/0/error +function/0/pcall +function/0/xpcall +function/0/loadfile +function/0/load +function/0/loadstring +function/0/dofile +function/0/gcinfo +function/0/collectgarbage +function/0/newproxy +function/0/print +string/_VERSION +function/0/coroutine.create +function/0/coroutine.yield +function/0/coroutine.resume +function/0/coroutine.wrap +function/0/coroutine.status +function/0/coroutine.running +function/0/coroutine.isyieldable +string/package.config +function/1/luasnip.util.extend_decorator.register +function/1/luasnip.util.extend_decorator.apply +function/2/nvim-tree.iterators.node-iterator.matcher +function/1/nvim-tree.iterators.node-iterator.iterate +function/2/nvim-tree.iterators.node-iterator.recursor +function/1/nvim-tree.iterators.node-iterator.builder +function/1/nvim-tree.iterators.node-iterator.hidden +function/2/nvim-tree.iterators.node-iterator.applier +function/1/lspconfig.util.get_other_matching_providers +function/1/lspconfig.util.validate_bufnr +function/2/lspconfig.util.add_hook_before +function/1/lspconfig.util.get_config_by_ft +function/1/lspconfig.util._parse_user_command_options +function/2/lspconfig.util.add_hook_after +function/0/lspconfig.util.available_servers +function/1/lspconfig.util.server_per_root_dir_manager +function/2/lspconfig.util.search_ancestors +boolean/lspconfig.util.default_config.capabilities.window.workDoneProgress +boolean/lspconfig.util.default_config.capabilities.window.showMessage.messageActionItem.additionalPropertiesSupport +boolean/lspconfig.util.default_config.capabilities.window.showDocument.support +boolean/lspconfig.util.default_config.capabilities.workspace.applyEdit +string/lspconfig.util.default_config.capabilities.workspace.workspaceEdit.resourceOperations.1 +string/lspconfig.util.default_config.capabilities.workspace.workspaceEdit.resourceOperations.2 +string/lspconfig.util.default_config.capabilities.workspace.workspaceEdit.resourceOperations.3 +boolean/lspconfig.util.default_config.capabilities.workspace.workspaceFolders +boolean/lspconfig.util.default_config.capabilities.workspace.configuration +boolean/lspconfig.util.default_config.capabilities.workspace.symbol.dynamicRegistration +boolean/lspconfig.util.default_config.capabilities.workspace.symbol.hierarchicalWorkspaceSymbolSupport +number/lspconfig.util.default_config.capabilities.workspace.symbol.symbolKind.valueSet.1 +number/lspconfig.util.default_config.capabilities.workspace.symbol.symbolKind.valueSet.2 +number/lspconfig.util.default_config.capabilities.workspace.symbol.symbolKind.valueSet.3 +number/lspconfig.util.default_config.capabilities.workspace.symbol.symbolKind.valueSet.4 +number/lspconfig.util.default_config.capabilities.workspace.symbol.symbolKind.valueSet.5 +number/lspconfig.util.default_config.capabilities.workspace.symbol.symbolKind.valueSet.6 +number/lspconfig.util.default_config.capabilities.workspace.symbol.symbolKind.valueSet.7 +number/lspconfig.util.default_config.capabilities.workspace.symbol.symbolKind.valueSet.8 +number/lspconfig.util.default_config.capabilities.workspace.symbol.symbolKind.valueSet.9 +number/lspconfig.util.default_config.capabilities.workspace.symbol.symbolKind.valueSet.10 +number/lspconfig.util.default_config.capabilities.workspace.symbol.symbolKind.valueSet.11 +number/lspconfig.util.default_config.capabilities.workspace.symbol.symbolKind.valueSet.12 +number/lspconfig.util.default_config.capabilities.workspace.symbol.symbolKind.valueSet.13 +number/lspconfig.util.default_config.capabilities.workspace.symbol.symbolKind.valueSet.14 +number/lspconfig.util.default_config.capabilities.workspace.symbol.symbolKind.valueSet.15 +number/lspconfig.util.default_config.capabilities.workspace.symbol.symbolKind.valueSet.16 +number/lspconfig.util.default_config.capabilities.workspace.symbol.symbolKind.valueSet.17 +number/lspconfig.util.default_config.capabilities.workspace.symbol.symbolKind.valueSet.18 +number/lspconfig.util.default_config.capabilities.workspace.symbol.symbolKind.valueSet.19 +number/lspconfig.util.default_config.capabilities.workspace.symbol.symbolKind.valueSet.20 +number/lspconfig.util.default_config.capabilities.workspace.symbol.symbolKind.valueSet.21 +number/lspconfig.util.default_config.capabilities.workspace.symbol.symbolKind.valueSet.22 +number/lspconfig.util.default_config.capabilities.workspace.symbol.symbolKind.valueSet.23 +number/lspconfig.util.default_config.capabilities.workspace.symbol.symbolKind.valueSet.24 +number/lspconfig.util.default_config.capabilities.workspace.symbol.symbolKind.valueSet.25 +number/lspconfig.util.default_config.capabilities.workspace.symbol.symbolKind.valueSet.26 +boolean/lspconfig.util.default_config.capabilities.textDocument.implementation.linkSupport +boolean/lspconfig.util.default_config.capabilities.textDocument.references.dynamicRegistration +boolean/lspconfig.util.default_config.capabilities.textDocument.rename.dynamicRegistration +boolean/lspconfig.util.default_config.capabilities.textDocument.rename.prepareSupport +boolean/lspconfig.util.default_config.capabilities.textDocument.documentHighlight.dynamicRegistration +boolean/lspconfig.util.default_config.capabilities.textDocument.documentSymbol.dynamicRegistration +boolean/lspconfig.util.default_config.capabilities.textDocument.documentSymbol.hierarchicalDocumentSymbolSupport +number/lspconfig.util.default_config.capabilities.textDocument.documentSymbol.symbolKind.valueSet.1 +number/lspconfig.util.default_config.capabilities.textDocument.documentSymbol.symbolKind.valueSet.2 +number/lspconfig.util.default_config.capabilities.textDocument.documentSymbol.symbolKind.valueSet.3 +number/lspconfig.util.default_config.capabilities.textDocument.documentSymbol.symbolKind.valueSet.4 +number/lspconfig.util.default_config.capabilities.textDocument.documentSymbol.symbolKind.valueSet.5 +number/lspconfig.util.default_config.capabilities.textDocument.documentSymbol.symbolKind.valueSet.6 +number/lspconfig.util.default_config.capabilities.textDocument.documentSymbol.symbolKind.valueSet.7 +number/lspconfig.util.default_config.capabilities.textDocument.documentSymbol.symbolKind.valueSet.8 +number/lspconfig.util.default_config.capabilities.textDocument.documentSymbol.symbolKind.valueSet.9 +number/lspconfig.util.default_config.capabilities.textDocument.documentSymbol.symbolKind.valueSet.10 +number/lspconfig.util.default_config.capabilities.textDocument.documentSymbol.symbolKind.valueSet.11 +number/lspconfig.util.default_config.capabilities.textDocument.documentSymbol.symbolKind.valueSet.12 +number/lspconfig.util.default_config.capabilities.textDocument.documentSymbol.symbolKind.valueSet.13 +number/lspconfig.util.default_config.capabilities.textDocument.documentSymbol.symbolKind.valueSet.14 +number/lspconfig.util.default_config.capabilities.textDocument.documentSymbol.symbolKind.valueSet.15 +number/lspconfig.util.default_config.capabilities.textDocument.documentSymbol.symbolKind.valueSet.16 +number/lspconfig.util.default_config.capabilities.textDocument.documentSymbol.symbolKind.valueSet.17 +number/lspconfig.util.default_config.capabilities.textDocument.documentSymbol.symbolKind.valueSet.18 +number/lspconfig.util.default_config.capabilities.textDocument.documentSymbol.symbolKind.valueSet.19 +number/lspconfig.util.default_config.capabilities.textDocument.documentSymbol.symbolKind.valueSet.20 +number/lspconfig.util.default_config.capabilities.textDocument.documentSymbol.symbolKind.valueSet.21 +number/lspconfig.util.default_config.capabilities.textDocument.documentSymbol.symbolKind.valueSet.22 +number/lspconfig.util.default_config.capabilities.textDocument.documentSymbol.symbolKind.valueSet.23 +number/lspconfig.util.default_config.capabilities.textDocument.documentSymbol.symbolKind.valueSet.24 +number/lspconfig.util.default_config.capabilities.textDocument.documentSymbol.symbolKind.valueSet.25 +number/lspconfig.util.default_config.capabilities.textDocument.documentSymbol.symbolKind.valueSet.26 +boolean/lspconfig.util.default_config.capabilities.textDocument.synchronization.dynamicRegistration +boolean/lspconfig.util.default_config.capabilities.textDocument.synchronization.willSave +boolean/lspconfig.util.default_config.capabilities.textDocument.synchronization.willSaveWaitUntil +boolean/lspconfig.util.default_config.capabilities.textDocument.synchronization.didSave +number/lspconfig.util.default_config.capabilities.textDocument.publishDiagnostics.tagSupport.valueSet.1 +number/lspconfig.util.default_config.capabilities.textDocument.publishDiagnostics.tagSupport.valueSet.2 +boolean/lspconfig.util.default_config.capabilities.textDocument.publishDiagnostics.relatedInformation +boolean/lspconfig.util.default_config.capabilities.textDocument.signatureHelp.dynamicRegistration +string/lspconfig.util.default_config.capabilities.textDocument.signatureHelp.signatureInformation.documentationFormat.1 +string/lspconfig.util.default_config.capabilities.textDocument.signatureHelp.signatureInformation.documentationFormat.2 +boolean/lspconfig.util.default_config.capabilities.textDocument.signatureHelp.signatureInformation.activeParameterSupport +boolean/lspconfig.util.default_config.capabilities.textDocument.signatureHelp.signatureInformation.parameterInformation.labelOffsetSupport +boolean/lspconfig.util.default_config.capabilities.textDocument.hover.dynamicRegistration +string/lspconfig.util.default_config.capabilities.textDocument.hover.contentFormat.1 +string/lspconfig.util.default_config.capabilities.textDocument.hover.contentFormat.2 +boolean/lspconfig.util.default_config.capabilities.textDocument.definition.linkSupport +boolean/lspconfig.util.default_config.capabilities.textDocument.declaration.linkSupport +boolean/lspconfig.util.default_config.capabilities.textDocument.completion.dynamicRegistration +boolean/lspconfig.util.default_config.capabilities.textDocument.completion.completionItem.preselectSupport +boolean/lspconfig.util.default_config.capabilities.textDocument.completion.completionItem.deprecatedSupport +string/lspconfig.util.default_config.capabilities.textDocument.completion.completionItem.documentationFormat.1 +string/lspconfig.util.default_config.capabilities.textDocument.completion.completionItem.documentationFormat.2 +boolean/lspconfig.util.default_config.capabilities.textDocument.completion.completionItem.snippetSupport +boolean/lspconfig.util.default_config.capabilities.textDocument.completion.completionItem.commitCharactersSupport +boolean/lspconfig.util.default_config.capabilities.textDocument.completion.contextSupport +number/lspconfig.util.default_config.capabilities.textDocument.completion.completionItemKind.valueSet.1 +number/lspconfig.util.default_config.capabilities.textDocument.completion.completionItemKind.valueSet.2 +number/lspconfig.util.default_config.capabilities.textDocument.completion.completionItemKind.valueSet.3 +number/lspconfig.util.default_config.capabilities.textDocument.completion.completionItemKind.valueSet.4 +number/lspconfig.util.default_config.capabilities.textDocument.completion.completionItemKind.valueSet.5 +number/lspconfig.util.default_config.capabilities.textDocument.completion.completionItemKind.valueSet.6 +number/lspconfig.util.default_config.capabilities.textDocument.completion.completionItemKind.valueSet.7 +number/lspconfig.util.default_config.capabilities.textDocument.completion.completionItemKind.valueSet.8 +number/lspconfig.util.default_config.capabilities.textDocument.completion.completionItemKind.valueSet.9 +number/lspconfig.util.default_config.capabilities.textDocument.completion.completionItemKind.valueSet.10 +number/lspconfig.util.default_config.capabilities.textDocument.completion.completionItemKind.valueSet.11 +number/lspconfig.util.default_config.capabilities.textDocument.completion.completionItemKind.valueSet.12 +number/lspconfig.util.default_config.capabilities.textDocument.completion.completionItemKind.valueSet.13 +number/lspconfig.util.default_config.capabilities.textDocument.completion.completionItemKind.valueSet.14 +number/lspconfig.util.default_config.capabilities.textDocument.completion.completionItemKind.valueSet.15 +number/lspconfig.util.default_config.capabilities.textDocument.completion.completionItemKind.valueSet.16 +number/lspconfig.util.default_config.capabilities.textDocument.completion.completionItemKind.valueSet.17 +number/lspconfig.util.default_config.capabilities.textDocument.completion.completionItemKind.valueSet.18 +number/lspconfig.util.default_config.capabilities.textDocument.completion.completionItemKind.valueSet.19 +number/lspconfig.util.default_config.capabilities.textDocument.completion.completionItemKind.valueSet.20 +number/lspconfig.util.default_config.capabilities.textDocument.completion.completionItemKind.valueSet.21 +number/lspconfig.util.default_config.capabilities.textDocument.completion.completionItemKind.valueSet.22 +number/lspconfig.util.default_config.capabilities.textDocument.completion.completionItemKind.valueSet.23 +number/lspconfig.util.default_config.capabilities.textDocument.completion.completionItemKind.valueSet.24 +number/lspconfig.util.default_config.capabilities.textDocument.completion.completionItemKind.valueSet.25 +boolean/lspconfig.util.default_config.capabilities.textDocument.typeDefinition.linkSupport +boolean/lspconfig.util.default_config.capabilities.textDocument.codeAction.dynamicRegistration +boolean/lspconfig.util.default_config.capabilities.textDocument.codeAction.isPreferredSupport +boolean/lspconfig.util.default_config.capabilities.textDocument.codeAction.dataSupport +string/lspconfig.util.default_config.capabilities.textDocument.codeAction.resolveSupport.properties.1 +string/lspconfig.util.default_config.capabilities.textDocument.codeAction.codeActionLiteralSupport.codeActionKind.valueSet.1 +string/lspconfig.util.default_config.capabilities.textDocument.codeAction.codeActionLiteralSupport.codeActionKind.valueSet.2 +string/lspconfig.util.default_config.capabilities.textDocument.codeAction.codeActionLiteralSupport.codeActionKind.valueSet.3 +string/lspconfig.util.default_config.capabilities.textDocument.codeAction.codeActionLiteralSupport.codeActionKind.valueSet.4 +string/lspconfig.util.default_config.capabilities.textDocument.codeAction.codeActionLiteralSupport.codeActionKind.valueSet.5 +string/lspconfig.util.default_config.capabilities.textDocument.codeAction.codeActionLiteralSupport.codeActionKind.valueSet.6 +string/lspconfig.util.default_config.capabilities.textDocument.codeAction.codeActionLiteralSupport.codeActionKind.valueSet.7 +string/lspconfig.util.default_config.capabilities.textDocument.codeAction.codeActionLiteralSupport.codeActionKind.valueSet.8 +string/lspconfig.util.default_config.capabilities.textDocument.codeAction.codeActionLiteralSupport.codeActionKind.valueSet.9 +string/lspconfig.util.default_config.capabilities.textDocument.codeAction.codeActionLiteralSupport.codeActionKind.valueSet.10 +string/lspconfig.util.default_config.capabilities.textDocument.codeAction.codeActionLiteralSupport.codeActionKind.valueSet.11 +string/lspconfig.util.default_config.capabilities.textDocument.codeAction.codeActionLiteralSupport.codeActionKind.valueSet.12 +string/lspconfig.util.default_config.capabilities.textDocument.codeAction.codeActionLiteralSupport.codeActionKind.valueSet.13 +string/lspconfig.util.default_config.capabilities.textDocument.codeAction.codeActionLiteralSupport.codeActionKind.valueSet.14 +string/lspconfig.util.default_config.capabilities.textDocument.codeAction.codeActionLiteralSupport.codeActionKind.valueSet.15 +string/lspconfig.util.default_config.capabilities.textDocument.codeAction.codeActionLiteralSupport.codeActionKind.valueSet.16 +boolean/lspconfig.util.default_config.capabilities.callHierarchy.dynamicRegistration +number/lspconfig.util.default_config.log_level +number/lspconfig.util.default_config.message_level +boolean/lspconfig.util.default_config.autostart +function/0/lspconfig.util.root_pattern +function/2/lspconfig.util.get_active_client_by_name +function/0/lspconfig.util.get_managed_clients +function/1/lspconfig.util.strip_archive_subpath +function/1/lspconfig.util.find_git_ancestor +function/1/lspconfig.util.find_mercurial_ancestor +function/1/lspconfig.util.get_active_clients_list_by_ft +function/1/lspconfig.util.find_node_modules_ancestor +function/1/lspconfig.util.find_package_json_ancestor +function/2/lspconfig.util.insert_package_json +function/1/lspconfig.util.path.escape_wildcards +function/0/lspconfig.util.path.join +function/1/lspconfig.util.path.exists +function/1/lspconfig.util.path.is_file +function/1/lspconfig.util.path.is_absolute +string/lspconfig.util.path.path_separator +function/1/lspconfig.util.path.sanitize +function/2/lspconfig.util.path.traverse_parents +function/1/lspconfig.util.path.iterate_parents +function/2/lspconfig.util.path.is_descendant +function/1/lspconfig.util.path.dirname +function/1/lspconfig.util.path.is_dir +function/2/lspconfig.util.create_module_commands +function/1/lspconfig.util.bufname_valid +function/0/bit.band +function/0/bit.bor +function/0/bit.bxor +function/0/bit.tohex +function/0/bit.tobit +function/0/bit.bnot +function/0/bit.bswap +function/0/bit.lshift +function/0/bit.rshift +function/0/bit.arshift +function/0/bit.rol +function/0/bit.ror +function/1/vim.filetype.detect.fs +function/1/vim.filetype.detect.r +function/1/vim.filetype.detect.dns_zone +function/2/vim.filetype.detect.csh +function/1/vim.filetype.detect.asm +function/1/vim.filetype.detect.asp +function/1/vim.filetype.detect.bas +function/2/vim.filetype.detect.bindzone +function/1/vim.filetype.detect.ent +function/1/vim.filetype.detect.control +function/1/vim.filetype.detect.copyright +function/1/vim.filetype.detect.frm +function/1/vim.filetype.detect.hw +function/1/vim.filetype.detect.idl +function/1/vim.filetype.detect.inc +function/1/vim.filetype.detect.inp +function/1/vim.filetype.detect.dtrace +function/1/vim.filetype.detect.nroff +function/1/vim.filetype.detect.lpc +function/1/vim.filetype.detect.mc +function/3/vim.filetype.detect.sh +function/1/vim.filetype.detect.mm +function/1/vim.filetype.detect.sig +function/1/vim.filetype.detect.change +function/1/vim.filetype.detect.sil +function/1/vim.filetype.detect.cls +function/1/vim.filetype.detect.web +function/1/vim.filetype.detect.progress_asm +function/1/vim.filetype.detect.progress_cweb +function/1/vim.filetype.detect.progress_pascal +function/1/vim.filetype.detect.redif +function/1/vim.filetype.detect.sc +function/1/vim.filetype.detect.scd +function/3/vim.filetype.detect.shell +function/1/vim.filetype.detect.y +function/1/vim.filetype.detect.rul +function/1/vim.filetype.detect.edn +function/1/vim.filetype.detect.smi +function/2/vim.filetype.detect.install +function/1/vim.filetype.detect.me +function/1/vim.filetype.detect.reg +function/1/vim.filetype.detect.ttl +function/1/vim.filetype.detect.class +function/1/vim.filetype.detect.sgml +function/1/vim.filetype.detect.foam +function/1/vim.filetype.detect.news +function/2/vim.filetype.detect.tex +function/1/vim.filetype.detect.psf +function/1/vim.filetype.detect.patch +function/1/vim.filetype.detect.pm +function/1/vim.filetype.detect.changelog +function/2/vim.filetype.detect.dat +function/2/vim.filetype.detect.dep3patch +function/1/vim.filetype.detect.pp +function/1/vim.filetype.detect.fvwm +function/2/vim.filetype.detect.mod +function/1/vim.filetype.detect.prg +function/1/vim.filetype.detect.printcap +function/1/vim.filetype.detect.sys +function/1/vim.filetype.detect.cfg +function/1/vim.filetype.detect.src +function/2/vim.filetype.detect.proto +function/2/vim.filetype.detect.match_contents +function/1/vim.filetype.detect.log +function/1/vim.filetype.detect.header +function/0/vim.filetype.detect.xfree86 +function/1/vim.filetype.detect.txt +function/1/vim.filetype.detect.git +function/1/vim.filetype.detect.tf +function/1/vim.filetype.detect.ex +function/1/vim.filetype.detect.e +function/1/vim.filetype.detect.html +function/1/vim.filetype.detect.pl +function/1/vim.filetype.detect.asm_syntax +function/1/vim.filetype.detect.xml +function/1/vim.filetype.detect.m +function/2/vim.filetype.detect.perl +function/1/vim.filetype.detect.mms +function/1/vim.filetype.detect.rules +function/1/vim.filetype.detect.decl +function/2/vim.filetype.detect.conf +function/1/luasnip.util.log.set_loglevel +function/0/luasnip.util.log.ping +function/0/luasnip.util.log.open +function/1/luasnip.util.log.new +boolean/nvim-tree.actions.node.open-file.resize_window +string/nvim-tree.actions.node.open-file.window_picker.exclude.filetype.1 +string/nvim-tree.actions.node.open-file.window_picker.exclude.filetype.2 +string/nvim-tree.actions.node.open-file.window_picker.exclude.filetype.3 +string/nvim-tree.actions.node.open-file.window_picker.exclude.filetype.4 +string/nvim-tree.actions.node.open-file.window_picker.exclude.filetype.5 +string/nvim-tree.actions.node.open-file.window_picker.exclude.filetype.6 +string/nvim-tree.actions.node.open-file.window_picker.exclude.buftype.1 +string/nvim-tree.actions.node.open-file.window_picker.exclude.buftype.2 +string/nvim-tree.actions.node.open-file.window_picker.exclude.buftype.3 +boolean/nvim-tree.actions.node.open-file.window_picker.enable +string/nvim-tree.actions.node.open-file.window_picker.picker +string/nvim-tree.actions.node.open-file.window_picker.chars +function/1/nvim-tree.actions.node.open-file.setup +function/2/nvim-tree.actions.node.open-file.fn +boolean/nvim-tree.actions.node.open-file.quit_on_open +function/1/nvim-tree.actions.root.dir-up.fn +boolean/cmp.utils.debug.flag +function/0/cmp.utils.debug.log +function/2/cmp.utils.str.escape +function/1/cmp.utils.str.oneline +function/2/cmp.utils.str.has_prefix +function/2/cmp.utils.str.get_common_string +function/3/cmp.utils.str.get_word +function/2/cmp.utils.str.remove_suffix +function/1/cmp.utils.str.trim +function/1/cmp.utils.char.is_alnum +function/1/cmp.utils.char.is_upper +function/1/cmp.utils.char.is_alpha +function/1/cmp.utils.char.is_digit +function/1/cmp.utils.char.is_symbol +function/2/cmp.utils.char.match +function/2/cmp.utils.char.is_semantic_index +function/1/cmp.utils.char.is_printable +function/2/cmp.utils.char.get_next_semantic_index +function/1/cmp.utils.char.is_white +function/2/cmp.utils.pattern.offset +function/2/cmp.utils.pattern.matchstr +function/1/cmp.utils.pattern.regex +userdata/cmp.utils.pattern._regexes.\%([^[:alnum:][:blank:]]\|\w\+\)\m$ +userdata/cmp.utils.pattern._regexes.^\%(\%(-\?\d\+\%(\.\d\+\)\?\|\h\w*\%(-\w*\)*\)\) +userdata/cmp.utils.pattern._regexes.[^[:blank:]]\+$ +userdata/cmp.utils.pattern._regexes.\%(-\?\d\+\%(\.\d\+\)\?\|\h\w*\%(-\w*\)*\)\m$ +function/2/cmp.context.get_offset +function/1/cmp.context.get_reason +function/1/cmp.context.clone +function/2/cmp.context.changed +function/0/cmp.context.empty +function/2/cmp.context.new +function/2/cmp.view.select_next_item +function/2/cmp.view.select_prev_item +function/1/cmp.view.visible +function/1/cmp.view.get_selected_entry +function/1/cmp.view.get_active_entry +function/1/cmp.view.get_entries +function/1/cmp.view.ready +function/1/cmp.view.abort +function/2/cmp.view.on_entry_change.sync +function/0/cmp.view.on_entry_change.stop +boolean/cmp.view.on_entry_change.running +number/cmp.view.on_entry_change.timeout +function/1/cmp.view.on_change +function/1/cmp.view._get_entries_view +function/3/cmp.view.open +function/2/cmp.view.scroll_docs +function/1/cmp.view.get_offset +function/1/cmp.view.get_first_entry +function/1/cmp.view.close +function/0/cmp.view.new +boolean/cmp.types.vim +string/cmp.types.cmp.ConfirmBehavior.Insert +string/cmp.types.cmp.ConfirmBehavior.Replace +string/cmp.types.cmp.TriggerEvent.TextChanged +string/cmp.types.cmp.TriggerEvent.InsertEnter +string/cmp.types.cmp.SelectBehavior.Insert +string/cmp.types.cmp.SelectBehavior.Select +string/cmp.types.cmp.ItemField.Abbr +string/cmp.types.cmp.ItemField.Kind +string/cmp.types.cmp.ItemField.Menu +string/cmp.types.cmp.PreselectMode.Item +string/cmp.types.cmp.PreselectMode.None +string/cmp.types.cmp.ContextReason.None +string/cmp.types.cmp.ContextReason.TriggerOnly +string/cmp.types.cmp.ContextReason.Auto +string/cmp.types.cmp.ContextReason.Manual +number/cmp.types.lsp.InsertTextMode.AsIs +number/cmp.types.lsp.InsertTextMode.AdjustIndentation +string/cmp.types.lsp.MarkupKind.PlainText +string/cmp.types.lsp.MarkupKind.Markdown +number/cmp.types.lsp.CompletionItemTag.Deprecated +number/cmp.types.lsp.InsertTextFormat.PlainText +number/cmp.types.lsp.InsertTextFormat.Snippet +string/cmp.types.lsp.CompletionItemKind.1 +string/cmp.types.lsp.CompletionItemKind.2 +string/cmp.types.lsp.CompletionItemKind.3 +string/cmp.types.lsp.CompletionItemKind.4 +string/cmp.types.lsp.CompletionItemKind.5 +string/cmp.types.lsp.CompletionItemKind.6 +string/cmp.types.lsp.CompletionItemKind.7 +string/cmp.types.lsp.CompletionItemKind.8 +string/cmp.types.lsp.CompletionItemKind.9 +string/cmp.types.lsp.CompletionItemKind.10 +string/cmp.types.lsp.CompletionItemKind.11 +string/cmp.types.lsp.CompletionItemKind.12 +string/cmp.types.lsp.CompletionItemKind.13 +string/cmp.types.lsp.CompletionItemKind.14 +string/cmp.types.lsp.CompletionItemKind.15 +string/cmp.types.lsp.CompletionItemKind.16 +string/cmp.types.lsp.CompletionItemKind.17 +string/cmp.types.lsp.CompletionItemKind.18 +string/cmp.types.lsp.CompletionItemKind.19 +string/cmp.types.lsp.CompletionItemKind.20 +string/cmp.types.lsp.CompletionItemKind.21 +string/cmp.types.lsp.CompletionItemKind.22 +string/cmp.types.lsp.CompletionItemKind.23 +string/cmp.types.lsp.CompletionItemKind.24 +string/cmp.types.lsp.CompletionItemKind.25 +number/cmp.types.lsp.CompletionItemKind.Property +number/cmp.types.lsp.CompletionItemKind.Unit +number/cmp.types.lsp.CompletionItemKind.Value +number/cmp.types.lsp.CompletionItemKind.Enum +number/cmp.types.lsp.CompletionItemKind.Color +number/cmp.types.lsp.CompletionItemKind.Function +number/cmp.types.lsp.CompletionItemKind.Reference +number/cmp.types.lsp.CompletionItemKind.Folder +number/cmp.types.lsp.CompletionItemKind.EnumMember +number/cmp.types.lsp.CompletionItemKind.Struct +number/cmp.types.lsp.CompletionItemKind.Operator +number/cmp.types.lsp.CompletionItemKind.Keyword +number/cmp.types.lsp.CompletionItemKind.TypeParameter +number/cmp.types.lsp.CompletionItemKind.File +number/cmp.types.lsp.CompletionItemKind.Constant +number/cmp.types.lsp.CompletionItemKind.Event +number/cmp.types.lsp.CompletionItemKind.Snippet +number/cmp.types.lsp.CompletionItemKind.Text +number/cmp.types.lsp.CompletionItemKind.Method +number/cmp.types.lsp.CompletionItemKind.Constructor +number/cmp.types.lsp.CompletionItemKind.Field +number/cmp.types.lsp.CompletionItemKind.Variable +number/cmp.types.lsp.CompletionItemKind.Class +number/cmp.types.lsp.CompletionItemKind.Interface +number/cmp.types.lsp.CompletionItemKind.Module +string/cmp.types.lsp.PositionEncodingKind.UTF32 +string/cmp.types.lsp.PositionEncodingKind.UTF8 +string/cmp.types.lsp.PositionEncodingKind.UTF16 +function/2/cmp.types.lsp.Range.to_vim +function/2/cmp.types.lsp.Range.to_lsp +number/cmp.types.lsp.CompletionTriggerKind.Invoked +number/cmp.types.lsp.CompletionTriggerKind.TriggerCharacter +number/cmp.types.lsp.CompletionTriggerKind.TriggerForIncompleteCompletions +function/2/cmp.types.lsp.Position.to_vim +function/3/cmp.types.lsp.Position.to_utf32 +function/2/cmp.types.lsp.Position.to_lsp +function/3/cmp.types.lsp.Position.to_utf8 +function/3/cmp.types.lsp.Position.to_utf16 +function/0/vscode.colors.get_colors +function/3/cmp.utils.event.on +function/3/cmp.utils.event.off +function/1/cmp.utils.event.clear +function/2/cmp.utils.event.emit +function/0/cmp.utils.event.new +function/1/cmp.view.docs_view.visible +function/1/cmp.view.docs_view.close +function/2/cmp.view.docs_view.scroll +function/3/cmp.view.docs_view.open +function/0/cmp.view.docs_view.new +function/0/nvim-tree.actions.finders.search-node.fn +function/1/luasnip.loaders.from_vscode._load_lazy_loaded_ft +function/1/luasnip.loaders.from_vscode._load_lazy_loaded +function/1/luasnip.loaders.from_vscode.load +function/1/luasnip.loaders.from_vscode.lazy_load +function/1/luasnip.loaders.from_vscode._reload_file +function/0/luasnip.loaders.from_vscode.edit_snippet_files +function/1/nvim-tree.actions.node.run-command.run_file_command +function/1/cmp.view.native_entries_view.get_entries +function/1/cmp.view.native_entries_view.ready +function/1/cmp.view.native_entries_view.abort +function/2/cmp.view.native_entries_view.select_next_item +function/1/cmp.view.native_entries_view.get_active_entry +function/2/cmp.view.native_entries_view.select_prev_item +function/1/cmp.view.native_entries_view.close +function/1/cmp.view.native_entries_view.info +function/1/cmp.view.native_entries_view.on_change +function/1/cmp.view.native_entries_view.visible +function/3/cmp.view.native_entries_view.open +function/1/cmp.view.native_entries_view.get_offset +function/2/cmp.view.native_entries_view.preselect +function/1/cmp.view.native_entries_view.get_first_entry +function/1/cmp.view.native_entries_view.get_selected_entry +function/0/cmp.view.native_entries_view.new +string/nvim-tree.actions.node.system-open.config.system_open.cmd +function/1/nvim-tree.actions.node.system-open.setup +function/1/nvim-tree.actions.node.system-open.fn +function/3/cmp.view.ghost_text_view.text_gen +function/1/cmp.view.ghost_text_view.hide +function/0/cmp.view.ghost_text_view.new +number/cmp.view.ghost_text_view.ns +function/2/cmp.view.ghost_text_view.show +number/luasnip.util.types.exitNode +number/luasnip.util.types.choiceNode +number/luasnip.util.types.snippet +string/luasnip.util.types.names_pascal_case.1 +string/luasnip.util.types.names_pascal_case.2 +string/luasnip.util.types.names_pascal_case.3 +string/luasnip.util.types.names_pascal_case.4 +string/luasnip.util.types.names_pascal_case.5 +string/luasnip.util.types.names_pascal_case.6 +string/luasnip.util.types.names_pascal_case.7 +string/luasnip.util.types.names_pascal_case.8 +string/luasnip.util.types.names_pascal_case.9 +number/luasnip.util.types.restoreNode +number/luasnip.util.types.functionNode +number/luasnip.util.types.node_types.1 +number/luasnip.util.types.node_types.2 +number/luasnip.util.types.node_types.3 +number/luasnip.util.types.node_types.4 +number/luasnip.util.types.node_types.5 +number/luasnip.util.types.node_types.6 +number/luasnip.util.types.node_types.7 +number/luasnip.util.types.node_types.8 +number/luasnip.util.types.node_types.9 +number/luasnip.util.types.dynamicNode +string/luasnip.util.types.names.1 +string/luasnip.util.types.names.2 +string/luasnip.util.types.names.3 +string/luasnip.util.types.names.4 +string/luasnip.util.types.names.5 +string/luasnip.util.types.names.6 +string/luasnip.util.types.names.7 +string/luasnip.util.types.names.8 +string/luasnip.util.types.names.9 +number/luasnip.util.types.insertNode +number/luasnip.util.types.textNode +number/luasnip.util.types.snippetNode +function/1/luasnip.util.ext_opts.clear_invalid +function/1/luasnip.util.ext_opts.child_complete +function/2/luasnip.util.ext_opts.child_extend +function/2/luasnip.util.ext_opts.extend +function/2/luasnip.util.ext_opts.child_set_abs_prio +function/2/luasnip.util.ext_opts.set_abs_prio +function/1/luasnip.util.ext_opts.complete +function/0/luasnip.extras.filetype_functions.from_pos_or_filetype +function/1/luasnip.extras.filetype_functions.extend_load_ft +function/0/luasnip.extras.filetype_functions.from_cursor_pos +function/0/luasnip.extras.filetype_functions.from_filetype +function/1/luasnip.extras.filetype_functions.from_filetype_load +function/2/Comment.utils.ignore +function/1/Comment.utils.is_empty +number/Comment.utils.cmotion.block +number/Comment.utils.cmotion.V +number/Comment.utils.cmotion.v +number/Comment.utils.cmotion.line +number/Comment.utils.cmotion.char +function/1/Comment.utils.get_pad +function/1/Comment.utils.get_padpat +function/5/Comment.utils.uncommenter +function/1/Comment.utils.get_region +function/1/Comment.utils.catch +function/5/Comment.utils.is_commented +function/1/Comment.utils.get_count_lines +function/1/Comment.utils.get_lines +function/1/Comment.utils.unwrap_cstr +function/1/Comment.utils.is_fn +number/Comment.utils.cmode.uncomment +number/Comment.utils.cmode.comment +number/Comment.utils.cmode.toggle +function/2/Comment.utils.parse_cstr +number/Comment.utils.ctype.linewise +number/Comment.utils.ctype.blockwise +function/6/Comment.utils.commenter +string/luasnip.session.config.ext_opts.1.unvisited.hl_group +string/luasnip.session.config.ext_opts.1.snippet_passive.hl_group +string/luasnip.session.config.ext_opts.1.passive.hl_group +string/luasnip.session.config.ext_opts.1.visited.hl_group +string/luasnip.session.config.ext_opts.1.active.hl_group +string/luasnip.session.config.ext_opts.2.unvisited.hl_group +string/luasnip.session.config.ext_opts.2.snippet_passive.hl_group +string/luasnip.session.config.ext_opts.2.passive.hl_group +string/luasnip.session.config.ext_opts.2.visited.hl_group +string/luasnip.session.config.ext_opts.2.active.hl_group +string/luasnip.session.config.ext_opts.3.unvisited.hl_group +string/luasnip.session.config.ext_opts.3.snippet_passive.hl_group +string/luasnip.session.config.ext_opts.3.passive.hl_group +string/luasnip.session.config.ext_opts.3.visited.hl_group +string/luasnip.session.config.ext_opts.3.active.hl_group +string/luasnip.session.config.ext_opts.4.unvisited.hl_group +string/luasnip.session.config.ext_opts.4.snippet_passive.hl_group +string/luasnip.session.config.ext_opts.4.passive.hl_group +string/luasnip.session.config.ext_opts.4.visited.hl_group +string/luasnip.session.config.ext_opts.4.active.hl_group +string/luasnip.session.config.ext_opts.5.unvisited.hl_group +string/luasnip.session.config.ext_opts.5.snippet_passive.hl_group +string/luasnip.session.config.ext_opts.5.passive.hl_group +string/luasnip.session.config.ext_opts.5.visited.hl_group +string/luasnip.session.config.ext_opts.5.active.hl_group +string/luasnip.session.config.ext_opts.6.unvisited.hl_group +string/luasnip.session.config.ext_opts.6.snippet_passive.hl_group +string/luasnip.session.config.ext_opts.6.passive.hl_group +string/luasnip.session.config.ext_opts.6.visited.hl_group +string/luasnip.session.config.ext_opts.6.active.hl_group +string/luasnip.session.config.ext_opts.7.unvisited.hl_group +string/luasnip.session.config.ext_opts.7.snippet_passive.hl_group +string/luasnip.session.config.ext_opts.7.passive.hl_group +string/luasnip.session.config.ext_opts.7.visited.hl_group +string/luasnip.session.config.ext_opts.7.active.hl_group +string/luasnip.session.config.ext_opts.8.unvisited.hl_group +string/luasnip.session.config.ext_opts.8.snippet_passive.hl_group +string/luasnip.session.config.ext_opts.8.passive.hl_group +string/luasnip.session.config.ext_opts.8.visited.hl_group +string/luasnip.session.config.ext_opts.8.active.hl_group +string/luasnip.session.config.ext_opts.9.unvisited.hl_group +string/luasnip.session.config.ext_opts.9.snippet_passive.hl_group +string/luasnip.session.config.ext_opts.9.passive.hl_group +string/luasnip.session.config.ext_opts.9.visited.hl_group +string/luasnip.session.config.ext_opts.9.active.hl_group +number/luasnip.session.config.ext_base_prio +number/luasnip.session.config.ext_prio_increase +boolean/luasnip.session.config.enable_autosnippets +function/2/luasnip.session.config.parser_nested_assembler +function/0/luasnip.session.config.ft_func +boolean/luasnip.session.config.history +string/luasnip.session.config.update_events +function/1/luasnip.session.config.load_ft_func +number/luasnip.session.ns_id +string/luasnip.session.ft_redirect..1 +string/luasnip.session.ft_redirect.nix.1 +string/luasnip.session.ft_redirect.all.1 +string/luasnip.session.ft_redirect.cmp_menu.1 +string/luasnip.session.ft_redirect.lua.1 +string/luasnip.session.ft_redirect.vim.1 +string/luasnip.session.ft_redirect.WhichKey.1 +string/luasnip.session.ft_redirect.cmp_docs.1 +string/luasnip.session.ft_redirect.help.1 +boolean/luasnip.session.jump_active +function/1/Comment.opfunc.linewise +function/4/Comment.opfunc.count +function/2/Comment.opfunc.blockwise +function/4/Comment.opfunc.opfunc +function/2/Comment.extra.insert_above +function/2/Comment.extra.insert_below +function/2/Comment.extra.insert_eol +function/3/luasnip.nodes.insertNode.I +function/1/vim.lsp.formatexpr +function/4/vim.lsp.codelens.on_codelens +function/3/vim.lsp.codelens.save +function/0/vim.lsp.codelens.refresh +function/3/vim.lsp.codelens.display +function/1/vim.lsp.codelens.get +function/0/vim.lsp.codelens.run +function/1/vim.lsp.rpc.format_rpc_error +function/2/vim.lsp.rpc.connect +string/vim.lsp.rpc.client_errors.1 +string/vim.lsp.rpc.client_errors.2 +string/vim.lsp.rpc.client_errors.3 +string/vim.lsp.rpc.client_errors.4 +string/vim.lsp.rpc.client_errors.5 +string/vim.lsp.rpc.client_errors.6 +string/vim.lsp.rpc.client_errors.7 +number/vim.lsp.rpc.client_errors.SERVER_RESULT_CALLBACK_ERROR +number/vim.lsp.rpc.client_errors.INVALID_SERVER_MESSAGE +number/vim.lsp.rpc.client_errors.INVALID_SERVER_JSON +number/vim.lsp.rpc.client_errors.NO_RESULT_CALLBACK_FOUND +number/vim.lsp.rpc.client_errors.READ_ERROR +number/vim.lsp.rpc.client_errors.NOTIFICATION_HANDLER_ERROR +number/vim.lsp.rpc.client_errors.SERVER_REQUEST_HANDLER_ERROR +function/3/vim.lsp.rpc.create_read_loop +function/4/vim.lsp.rpc.start +function/3/vim.lsp.rpc.rpc_response_error +function/3/vim.lsp.rpc_response_error +string/vim.lsp._request_name_to_capability.textDocument/prepareCallHierarchy.1 +string/vim.lsp._request_name_to_capability.textDocument/rename.1 +string/vim.lsp._request_name_to_capability.textDocument/prepareRename.1 +string/vim.lsp._request_name_to_capability.textDocument/prepareRename.2 +string/vim.lsp._request_name_to_capability.textDocument/codeAction.1 +string/vim.lsp._request_name_to_capability.textDocument/codeLens.1 +string/vim.lsp._request_name_to_capability.textDocument/hover.1 +string/vim.lsp._request_name_to_capability.codeLens/resolve.1 +string/vim.lsp._request_name_to_capability.codeLens/resolve.2 +string/vim.lsp._request_name_to_capability.textDocument/signatureHelp.1 +string/vim.lsp._request_name_to_capability.workspace/executeCommand.1 +string/vim.lsp._request_name_to_capability.textDocument/definition.1 +string/vim.lsp._request_name_to_capability.workspace/symbol.1 +string/vim.lsp._request_name_to_capability.textDocument/implementation.1 +string/vim.lsp._request_name_to_capability.textDocument/references.1 +string/vim.lsp._request_name_to_capability.textDocument/rangeFormatting.1 +string/vim.lsp._request_name_to_capability.textDocument/formatting.1 +string/vim.lsp._request_name_to_capability.textDocument/completion.1 +string/vim.lsp._request_name_to_capability.textDocument/documentHighlight.1 +string/vim.lsp._request_name_to_capability.textDocument/declaration.1 +string/vim.lsp._request_name_to_capability.textDocument/typeDefinition.1 +string/vim.lsp._request_name_to_capability.textDocument/documentSymbol.1 +function/4/vim.lsp.buf_request +function/4/vim.lsp.diagnostic.get_line_diagnostics +function/1/vim.lsp.diagnostic.get_namespace +function/2/vim.lsp.diagnostic.reset +function/4/vim.lsp.diagnostic.on_publish_diagnostics +function/4/vim.lsp.buf_request_all +function/2/vim.lsp.for_each_buffer_client +function/4/vim.lsp.buf_request_sync +function/1/vim.lsp.buf.implementation +function/0/vim.lsp.buf.server_ready +function/2/vim.lsp.buf.references +function/2/vim.lsp.buf.rename +function/0/vim.lsp.buf.incoming_calls +function/0/vim.lsp.buf.outgoing_calls +function/0/vim.lsp.buf.signature_help +function/1/vim.lsp.buf.execute_command +function/1/vim.lsp.buf.type_definition +function/3/vim.lsp.buf.range_code_action +function/1/vim.lsp.buf.code_action +function/2/vim.lsp.buf.formatting_sync +function/0/vim.lsp.buf.document_highlight +function/0/vim.lsp.buf.clear_references +function/3/vim.lsp.buf.formatting_seq_sync +function/1/vim.lsp.buf.add_workspace_folder +function/2/vim.lsp.buf.workspace_symbol +function/3/vim.lsp.buf.range_formatting +function/1/vim.lsp.buf.document_symbol +function/1/vim.lsp.buf.remove_workspace_folder +function/0/vim.lsp.buf.list_workspace_folders +function/1/vim.lsp.buf.formatting +function/0/vim.lsp.buf.hover +function/1/vim.lsp.buf.declaration +function/1/vim.lsp.buf.completion +function/1/vim.lsp.buf.definition +function/1/vim.lsp.buf.format +function/3/vim.lsp.buf_notify +function/2/vim.lsp.buf_is_attached +function/1/vim.lsp._cmd_parts +function/1/vim.lsp.get_active_clients +function/2/vim.lsp.buf_attach_client +function/1/vim.lsp.start_client +function/3/vim.lsp._with_extend +function/4/vim.lsp.handlers.callHierarchy/incomingCalls +function/4/vim.lsp.handlers.textDocument/rename +function/4/vim.lsp.handlers.client/registerCapability +function/4/vim.lsp.handlers.window/showMessage +function/4/vim.lsp.handlers.window/logMessage +function/4/vim.lsp.handlers.callHierarchy/outgoingCalls +function/4/vim.lsp.handlers.textDocument/codeLens +function/4/vim.lsp.handlers.workspace/applyEdit +function/4/vim.lsp.handlers.textDocument/declaration +function/4/vim.lsp.handlers.signature_help +function/4/vim.lsp.handlers.workspace/executeCommand +function/4/vim.lsp.handlers.textDocument/definition +function/4/vim.lsp.handlers.workspace/symbol +function/4/vim.lsp.handlers.workspace/configuration +function/4/vim.lsp.handlers.textDocument/references +function/4/vim.lsp.handlers.textDocument/signatureHelp +function/4/vim.lsp.handlers.textDocument/rangeFormatting +function/4/vim.lsp.handlers.workspace/workspaceFolders +function/4/vim.lsp.handlers.textDocument/formatting +function/4/vim.lsp.handlers.textDocument/implementation +function/4/vim.lsp.handlers.textDocument/publishDiagnostics +function/4/vim.lsp.handlers.textDocument/typeDefinition +function/4/vim.lsp.handlers.textDocument/documentHighlight +function/4/vim.lsp.handlers.$/progress +function/4/vim.lsp.handlers.window/workDoneProgress/create +function/4/vim.lsp.handlers.textDocument/hover +function/4/vim.lsp.handlers.window/showMessageRequest +function/4/vim.lsp.handlers.hover +function/4/vim.lsp.handlers.textDocument/documentSymbol +function/4/vim.lsp.handlers.textDocument/completion +function/2/vim.lsp.start +function/0/vim.lsp.get_log_path +function/1/vim.lsp.set_log_level +function/0/vim.lsp.client +string/vim.lsp.client_errors.1 +string/vim.lsp.client_errors.2 +string/vim.lsp.client_errors.3 +string/vim.lsp.client_errors.4 +string/vim.lsp.client_errors.5 +string/vim.lsp.client_errors.6 +string/vim.lsp.client_errors.7 +string/vim.lsp.client_errors.8 +number/vim.lsp.client_errors.SERVER_RESULT_CALLBACK_ERROR +number/vim.lsp.client_errors.ON_INIT_CALLBACK_ERROR +number/vim.lsp.client_errors.INVALID_SERVER_MESSAGE +number/vim.lsp.client_errors.INVALID_SERVER_JSON +number/vim.lsp.client_errors.NO_RESULT_CALLBACK_FOUND +number/vim.lsp.client_errors.READ_ERROR +number/vim.lsp.client_errors.NOTIFICATION_HANDLER_ERROR +number/vim.lsp.client_errors.SERVER_REQUEST_HANDLER_ERROR +function/1/vim.lsp.client_is_stopped +function/1/vim.lsp.buf_get_clients +string/vim.lsp.log_levels.0 +string/vim.lsp.log_levels.1 +string/vim.lsp.log_levels.2 +string/vim.lsp.log_levels.3 +string/vim.lsp.log_levels.4 +string/vim.lsp.log_levels.5 +number/vim.lsp.log_levels.INFO +number/vim.lsp.log_levels.DEBUG +number/vim.lsp.log_levels.TRACE +number/vim.lsp.log_levels.WARN +number/vim.lsp.log_levels.ERROR +number/vim.lsp.log_levels.OFF +function/3/vim.lsp.util.rename +function/1/vim.lsp.util.parse_snippet +function/3/vim.lsp.util.open_floating_preview +function/1/vim.lsp.util._get_symbol_kind_name +function/0/vim.lsp.util.get_progress_messages +function/3/vim.lsp.util.stylize_markdown +function/1/vim.lsp.util.trim_empty_lines +function/2/vim.lsp.util._make_floating_popup_size +function/1/vim.lsp.util.try_trim_markdown_code_blocks +function/1/vim.lsp.util._get_offset_encoding +function/1/vim.lsp.util.make_text_document_params +function/3/vim.lsp.util.make_floating_popup_options +function/2/vim.lsp.util.make_range_params +function/4/vim.lsp.util.make_given_range_params +function/3/vim.lsp.util.apply_text_document_edit +function/2/vim.lsp.util.make_workspace_params +function/2/vim.lsp.util.make_position_params +function/1/vim.lsp.util.extract_completion_items +number/vim.lsp.util.buf_versions.1 +function/2/vim.lsp.util.text_document_completion_list_to_complete_items +function/2/vim.lsp.util.apply_workspace_edit +function/2/vim.lsp.util.convert_input_to_markdown_lines +function/2/vim.lsp.util.preview_location +function/1/vim.lsp.util._get_completion_item_kind_name +function/3/vim.lsp.util._str_utfindex_enc +function/3/vim.lsp.util._get_line_byte_from_position +function/2/vim.lsp.util._trim +function/2/vim.lsp.util.lookup_section +function/4/vim.lsp.util.character_offset +function/3/vim.lsp.util.convert_signature_help_to_markdown_lines +function/1/vim.lsp.util.make_formatting_params +function/3/vim.lsp.util.apply_text_edits +function/1/vim.lsp.util.get_effective_tabstop +function/3/vim.lsp.util.buf_highlight_references +function/3/vim.lsp.util._str_byteindex_enc +function/2/vim.lsp.util.locations_to_items +function/4/vim.lsp.util.set_lines +function/1/vim.lsp.util.buf_clear_references +function/3/vim.lsp.util.jump_to_location +function/2/vim.lsp.util.symbols_to_items +function/1/vim.lsp.get_buffers_by_client_id +function/1/vim.lsp.protocol.resolve_capabilities +string/vim.lsp.protocol.DocumentHighlightKind.1 +string/vim.lsp.protocol.DocumentHighlightKind.2 +string/vim.lsp.protocol.DocumentHighlightKind.3 +number/vim.lsp.protocol.DocumentHighlightKind.Text +number/vim.lsp.protocol.DocumentHighlightKind.Write +number/vim.lsp.protocol.DocumentHighlightKind.Read +string/vim.lsp.protocol.InitializeError.1 +number/vim.lsp.protocol.InitializeError.unknownProtocolVersion +string/vim.lsp.protocol.WatchKind.1 +string/vim.lsp.protocol.WatchKind.2 +number/vim.lsp.protocol.WatchKind.Delete +string/vim.lsp.protocol.WatchKind.4 +number/vim.lsp.protocol.WatchKind.Create +number/vim.lsp.protocol.WatchKind.Change +string/vim.lsp.protocol.MessageType.1 +string/vim.lsp.protocol.MessageType.2 +string/vim.lsp.protocol.MessageType.3 +string/vim.lsp.protocol.MessageType.4 +number/vim.lsp.protocol.MessageType.Warning +number/vim.lsp.protocol.MessageType.Log +number/vim.lsp.protocol.MessageType.Info +number/vim.lsp.protocol.MessageType.Error +string/vim.lsp.protocol.CodeActionKind.RefactorInline +string/vim.lsp.protocol.CodeActionKind.refactor.inline +string/vim.lsp.protocol.CodeActionKind.RefactorRewrite +string/vim.lsp.protocol.CodeActionKind.refactor.rewrite +string/vim.lsp.protocol.CodeActionKind.Source +string/vim.lsp.protocol.CodeActionKind.SourceOrganizeImports +string/vim.lsp.protocol.CodeActionKind.source.organizeImports +string/vim.lsp.protocol.CodeActionKind.source +string/vim.lsp.protocol.CodeActionKind. +string/vim.lsp.protocol.CodeActionKind.Empty +string/vim.lsp.protocol.CodeActionKind.QuickFix +string/vim.lsp.protocol.CodeActionKind.quickfix +string/vim.lsp.protocol.CodeActionKind.Refactor +string/vim.lsp.protocol.CodeActionKind.refactor +string/vim.lsp.protocol.CodeActionKind.RefactorExtract +string/vim.lsp.protocol.CodeActionKind.refactor.extract +function/1/vim.lsp.protocol._resolve_capabilities_compat +string/vim.lsp.protocol.CompletionTriggerKind.1 +string/vim.lsp.protocol.CompletionTriggerKind.2 +string/vim.lsp.protocol.CompletionTriggerKind.3 +number/vim.lsp.protocol.CompletionTriggerKind.Invoked +number/vim.lsp.protocol.CompletionTriggerKind.TriggerCharacter +number/vim.lsp.protocol.CompletionTriggerKind.TriggerForIncompleteCompletions +string/vim.lsp.protocol.TextDocumentSaveReason.1 +string/vim.lsp.protocol.TextDocumentSaveReason.2 +string/vim.lsp.protocol.TextDocumentSaveReason.3 +number/vim.lsp.protocol.TextDocumentSaveReason.FocusOut +number/vim.lsp.protocol.TextDocumentSaveReason.AfterDelay +number/vim.lsp.protocol.TextDocumentSaveReason.Manual +string/vim.lsp.protocol.TextDocumentSyncKind.0 +string/vim.lsp.protocol.TextDocumentSyncKind.1 +string/vim.lsp.protocol.TextDocumentSyncKind.2 +number/vim.lsp.protocol.TextDocumentSyncKind.None +number/vim.lsp.protocol.TextDocumentSyncKind.Incremental +number/vim.lsp.protocol.TextDocumentSyncKind.Full +string/vim.lsp.protocol.ErrorCodes.-32603 +string/vim.lsp.protocol.ErrorCodes.-32700 +string/vim.lsp.protocol.ErrorCodes.-32000 +string/vim.lsp.protocol.ErrorCodes.-32002 +number/vim.lsp.protocol.ErrorCodes.ContentModified +string/vim.lsp.protocol.ErrorCodes.-32800 +number/vim.lsp.protocol.ErrorCodes.ParseError +number/vim.lsp.protocol.ErrorCodes.InvalidRequest +number/vim.lsp.protocol.ErrorCodes.InvalidParams +number/vim.lsp.protocol.ErrorCodes.InternalError +number/vim.lsp.protocol.ErrorCodes.serverErrorStart +number/vim.lsp.protocol.ErrorCodes.MethodNotFound +number/vim.lsp.protocol.ErrorCodes.ServerNotInitialized +number/vim.lsp.protocol.ErrorCodes.UnknownErrorCode +number/vim.lsp.protocol.ErrorCodes.RequestCancelled +string/vim.lsp.protocol.ErrorCodes.-32099 +string/vim.lsp.protocol.ErrorCodes.-32001 +string/vim.lsp.protocol.ErrorCodes.-32801 +string/vim.lsp.protocol.ErrorCodes.-32601 +string/vim.lsp.protocol.ErrorCodes.-32602 +number/vim.lsp.protocol.ErrorCodes.serverErrorEnd +string/vim.lsp.protocol.ErrorCodes.-32600 +string/vim.lsp.protocol.InsertTextFormat.1 +string/vim.lsp.protocol.InsertTextFormat.2 +number/vim.lsp.protocol.InsertTextFormat.PlainText +number/vim.lsp.protocol.InsertTextFormat.Snippet +string/vim.lsp.protocol.CompletionItemKind.1 +string/vim.lsp.protocol.CompletionItemKind.2 +string/vim.lsp.protocol.CompletionItemKind.3 +string/vim.lsp.protocol.CompletionItemKind.4 +string/vim.lsp.protocol.CompletionItemKind.5 +string/vim.lsp.protocol.CompletionItemKind.6 +string/vim.lsp.protocol.CompletionItemKind.7 +string/vim.lsp.protocol.CompletionItemKind.8 +string/vim.lsp.protocol.CompletionItemKind.9 +string/vim.lsp.protocol.CompletionItemKind.10 +string/vim.lsp.protocol.CompletionItemKind.11 +string/vim.lsp.protocol.CompletionItemKind.12 +string/vim.lsp.protocol.CompletionItemKind.13 +string/vim.lsp.protocol.CompletionItemKind.14 +string/vim.lsp.protocol.CompletionItemKind.15 +string/vim.lsp.protocol.CompletionItemKind.16 +string/vim.lsp.protocol.CompletionItemKind.17 +string/vim.lsp.protocol.CompletionItemKind.18 +string/vim.lsp.protocol.CompletionItemKind.19 +string/vim.lsp.protocol.CompletionItemKind.20 +string/vim.lsp.protocol.CompletionItemKind.21 +string/vim.lsp.protocol.CompletionItemKind.22 +string/vim.lsp.protocol.CompletionItemKind.23 +string/vim.lsp.protocol.CompletionItemKind.24 +string/vim.lsp.protocol.CompletionItemKind.25 +number/vim.lsp.protocol.CompletionItemKind.Property +number/vim.lsp.protocol.CompletionItemKind.Unit +number/vim.lsp.protocol.CompletionItemKind.Value +number/vim.lsp.protocol.CompletionItemKind.Enum +number/vim.lsp.protocol.CompletionItemKind.Color +number/vim.lsp.protocol.CompletionItemKind.Function +number/vim.lsp.protocol.CompletionItemKind.Reference +number/vim.lsp.protocol.CompletionItemKind.Folder +number/vim.lsp.protocol.CompletionItemKind.EnumMember +number/vim.lsp.protocol.CompletionItemKind.Struct +number/vim.lsp.protocol.CompletionItemKind.Operator +number/vim.lsp.protocol.CompletionItemKind.Keyword +number/vim.lsp.protocol.CompletionItemKind.File +number/vim.lsp.protocol.CompletionItemKind.TypeParameter +number/vim.lsp.protocol.CompletionItemKind.Class +number/vim.lsp.protocol.CompletionItemKind.Snippet +number/vim.lsp.protocol.CompletionItemKind.Event +number/vim.lsp.protocol.CompletionItemKind.Text +number/vim.lsp.protocol.CompletionItemKind.Method +number/vim.lsp.protocol.CompletionItemKind.Constructor +number/vim.lsp.protocol.CompletionItemKind.Field +number/vim.lsp.protocol.CompletionItemKind.Variable +number/vim.lsp.protocol.CompletionItemKind.Constant +number/vim.lsp.protocol.CompletionItemKind.Interface +number/vim.lsp.protocol.CompletionItemKind.Module +string/vim.lsp.protocol.MarkupKind.PlainText +string/vim.lsp.protocol.MarkupKind.markdown +string/vim.lsp.protocol.MarkupKind.Markdown +string/vim.lsp.protocol.MarkupKind.plaintext +string/vim.lsp.protocol.ResourceOperationKind.create +string/vim.lsp.protocol.ResourceOperationKind.Rename +string/vim.lsp.protocol.ResourceOperationKind.Create +string/vim.lsp.protocol.ResourceOperationKind.Delete +string/vim.lsp.protocol.ResourceOperationKind.rename +string/vim.lsp.protocol.ResourceOperationKind.delete +string/vim.lsp.protocol.DiagnosticSeverity.1 +string/vim.lsp.protocol.DiagnosticSeverity.2 +string/vim.lsp.protocol.DiagnosticSeverity.3 +string/vim.lsp.protocol.DiagnosticSeverity.4 +number/vim.lsp.protocol.DiagnosticSeverity.Warning +number/vim.lsp.protocol.DiagnosticSeverity.Information +number/vim.lsp.protocol.DiagnosticSeverity.Hint +number/vim.lsp.protocol.DiagnosticSeverity.Error +function/0/vim.lsp.protocol.make_client_capabilities +string/vim.lsp.protocol.FailureHandlingKind.TextOnlyTransactional +string/vim.lsp.protocol.FailureHandlingKind.textOnlyTransactional +string/vim.lsp.protocol.FailureHandlingKind.Undo +string/vim.lsp.protocol.FailureHandlingKind.undo +string/vim.lsp.protocol.FailureHandlingKind.abort +string/vim.lsp.protocol.FailureHandlingKind.Abort +string/vim.lsp.protocol.FailureHandlingKind.Transactional +string/vim.lsp.protocol.FailureHandlingKind.transactional +string/vim.lsp.protocol.DiagnosticTag.1 +string/vim.lsp.protocol.DiagnosticTag.2 +number/vim.lsp.protocol.DiagnosticTag.Unnecessary +number/vim.lsp.protocol.DiagnosticTag.Deprecated +string/vim.lsp.protocol.SymbolKind.1 +string/vim.lsp.protocol.SymbolKind.2 +string/vim.lsp.protocol.SymbolKind.3 +string/vim.lsp.protocol.SymbolKind.4 +string/vim.lsp.protocol.SymbolKind.5 +string/vim.lsp.protocol.SymbolKind.6 +string/vim.lsp.protocol.SymbolKind.7 +string/vim.lsp.protocol.SymbolKind.8 +string/vim.lsp.protocol.SymbolKind.9 +string/vim.lsp.protocol.SymbolKind.10 +string/vim.lsp.protocol.SymbolKind.11 +string/vim.lsp.protocol.SymbolKind.12 +string/vim.lsp.protocol.SymbolKind.13 +string/vim.lsp.protocol.SymbolKind.14 +string/vim.lsp.protocol.SymbolKind.15 +string/vim.lsp.protocol.SymbolKind.16 +string/vim.lsp.protocol.SymbolKind.17 +string/vim.lsp.protocol.SymbolKind.18 +string/vim.lsp.protocol.SymbolKind.19 +string/vim.lsp.protocol.SymbolKind.20 +string/vim.lsp.protocol.SymbolKind.21 +string/vim.lsp.protocol.SymbolKind.22 +string/vim.lsp.protocol.SymbolKind.23 +string/vim.lsp.protocol.SymbolKind.24 +string/vim.lsp.protocol.SymbolKind.25 +string/vim.lsp.protocol.SymbolKind.26 +number/vim.lsp.protocol.SymbolKind.Property +number/vim.lsp.protocol.SymbolKind.Boolean +number/vim.lsp.protocol.SymbolKind.Enum +number/vim.lsp.protocol.SymbolKind.Function +number/vim.lsp.protocol.SymbolKind.Namespace +number/vim.lsp.protocol.SymbolKind.EnumMember +number/vim.lsp.protocol.SymbolKind.Struct +number/vim.lsp.protocol.SymbolKind.Object +number/vim.lsp.protocol.SymbolKind.Key +number/vim.lsp.protocol.SymbolKind.Null +number/vim.lsp.protocol.SymbolKind.File +number/vim.lsp.protocol.SymbolKind.String +number/vim.lsp.protocol.SymbolKind.Constant +number/vim.lsp.protocol.SymbolKind.Number +number/vim.lsp.protocol.SymbolKind.Array +number/vim.lsp.protocol.SymbolKind.Operator +number/vim.lsp.protocol.SymbolKind.TypeParameter +number/vim.lsp.protocol.SymbolKind.Event +number/vim.lsp.protocol.SymbolKind.Package +number/vim.lsp.protocol.SymbolKind.Method +number/vim.lsp.protocol.SymbolKind.Constructor +number/vim.lsp.protocol.SymbolKind.Field +number/vim.lsp.protocol.SymbolKind.Variable +number/vim.lsp.protocol.SymbolKind.Class +number/vim.lsp.protocol.SymbolKind.Interface +number/vim.lsp.protocol.SymbolKind.Module +string/vim.lsp.protocol.FileChangeType.1 +string/vim.lsp.protocol.FileChangeType.2 +number/vim.lsp.protocol.FileChangeType.Created +number/vim.lsp.protocol.FileChangeType.Changed +number/vim.lsp.protocol.FileChangeType.Deleted +string/vim.lsp.protocol.FileChangeType.3 +function/2/vim.lsp.buf_detach_client +function/1/vim.lsp.get_client_by_id +function/2/vim.lsp.with +function/1/vim.lsp._unsupported_method +function/0/vim.lsp.tagfunc +function/2/vim.lsp.stop_client +function/2/vim.lsp.omnifunc +function/3/luasnip.nodes.snippet._S +function/3/luasnip.nodes.snippet.SN +function/4/luasnip.nodes.snippet.ISN +function/1/luasnip.nodes.snippet.init_snippet_context +function/1/luasnip.nodes.snippet.init_snippet_opts +function/1/luasnip.nodes.snippet.wrap_nodes_in_snippetNode +function/1/luasnip.nodes.snippet.Snippet.resolve_child_ext_opts +function/3/luasnip.nodes.snippet.Snippet.set_text +function/1/luasnip.nodes.snippet.Snippet.del_marks +function/2/luasnip.nodes.snippet.Snippet.enter_node +function/2/luasnip.nodes.snippet.Snippet.fake_expand +function/1/luasnip.nodes.snippet.Snippet.exit +boolean/luasnip.nodes.snippet.Snippet.visible +function/1/luasnip.nodes.snippet.Snippet.static_init +function/1/luasnip.nodes.snippet.Snippet.update_static +function/1/luasnip.nodes.snippet.Snippet.get_static_text +boolean/luasnip.nodes.snippet.Snippet.static_visible +function/1/luasnip.nodes.snippet.Snippet.copy +function/2/luasnip.nodes.snippet.Snippet.matches +function/1/luasnip.nodes.snippet.Snippet.dump +function/2/luasnip.nodes.snippet.Snippet.indent +function/3/luasnip.nodes.snippet.Snippet.input_enter +function/1/luasnip.nodes.snippet.Snippet.get_pattern_expand_helper +function/2/luasnip.nodes.snippet.Snippet.set_ext_opts +function/3/luasnip.nodes.snippet.Snippet.expand_tabs +boolean/luasnip.nodes.snippet.Snippet.merge_node_ext_opts +function/1/luasnip.nodes.snippet.Snippet.invalidate +function/1/luasnip.nodes.snippet.Snippet.update +boolean/luasnip.nodes.snippet.Snippet.visited +function/1/luasnip.nodes.snippet.Snippet.remove_from_jumplist +function/2/luasnip.nodes.snippet.Snippet.set_argnodes +function/1/luasnip.nodes.snippet.Snippet.subsnip_init +function/2/luasnip.nodes.snippet.Snippet.init_positions +function/2/luasnip.nodes.snippet.Snippet.init_insert_positions +function/1/luasnip.nodes.snippet.Snippet.make_args_absolute +function/1/luasnip.nodes.snippet.Snippet.text_only +function/3/luasnip.nodes.snippet.Snippet.event +function/1/luasnip.nodes.snippet.Snippet.set_dependents +function/4/luasnip.nodes.snippet.Snippet.trigger_expand +function/2/luasnip.nodes.snippet.Snippet.put_initial +function/2/luasnip.nodes.snippet.Snippet.insert_to_node_absolute +function/2/luasnip.nodes.snippet.Snippet.is_interactive +function/3/luasnip.nodes.snippet.Snippet.input_leave +function/1/luasnip.nodes.snippet.Snippet.update_all_dependents +function/4/luasnip.nodes.snippet.Snippet.jump_into +function/2/luasnip.nodes.snippet.Snippet.find_node +number/luasnip.nodes.snippet.Snippet.node_ext_opts.base_prio +function/3/luasnip.nodes.snippet.Snippet.set_mark_rgrav +function/1/luasnip.nodes.snippet.Snippet.get_docstring +function/1/luasnip.nodes.snippet.Snippet.init_nodes +function/1/luasnip.nodes.snippet.Snippet.update_restore +function/1/luasnip.nodes.snippet.Snippet.update_all_dependents_static +function/1/luasnip.nodes.snippet.Snippet.store +function/2/luasnip.nodes.snippet.Snippet.resolve_position +function/1/luasnip.nodes.snippet.P +function/3/luasnip.nodes.snippet.S +boolean/nvim-tree.renderer.components.modified.show_icon +function/1/nvim-tree.renderer.components.modified.setup +function/0/nvim-tree.renderer.components.modified.setup_signs +function/1/nvim-tree.renderer.components.modified.get_highlight +string/nvim-tree.renderer.components.modified.icon +function/1/nvim-tree.renderer.components.modified.get_icon +boolean/nvim-tree.renderer.components.padding.config.indent_markers.inline_arrows +string/nvim-tree.renderer.components.padding.config.indent_markers.icons.none +string/nvim-tree.renderer.components.padding.config.indent_markers.icons.corner +string/nvim-tree.renderer.components.padding.config.indent_markers.icons.edge +string/nvim-tree.renderer.components.padding.config.indent_markers.icons.item +string/nvim-tree.renderer.components.padding.config.indent_markers.icons.bottom +boolean/nvim-tree.renderer.components.padding.config.indent_markers.enable +boolean/nvim-tree.renderer.components.padding.config.symlink_destination +string/nvim-tree.renderer.components.padding.config.icons.git_placement +string/nvim-tree.renderer.components.padding.config.icons.modified_placement +string/nvim-tree.renderer.components.padding.config.icons.glyphs.default +string/nvim-tree.renderer.components.padding.config.icons.glyphs.git.unstaged +string/nvim-tree.renderer.components.padding.config.icons.glyphs.git.staged +string/nvim-tree.renderer.components.padding.config.icons.glyphs.git.ignored +string/nvim-tree.renderer.components.padding.config.icons.glyphs.git.unmerged +string/nvim-tree.renderer.components.padding.config.icons.glyphs.git.deleted +string/nvim-tree.renderer.components.padding.config.icons.glyphs.git.renamed +string/nvim-tree.renderer.components.padding.config.icons.glyphs.git.untracked +string/nvim-tree.renderer.components.padding.config.icons.glyphs.symlink +string/nvim-tree.renderer.components.padding.config.icons.glyphs.folder.default +string/nvim-tree.renderer.components.padding.config.icons.glyphs.folder.arrow_closed +string/nvim-tree.renderer.components.padding.config.icons.glyphs.folder.open +string/nvim-tree.renderer.components.padding.config.icons.glyphs.folder.empty +string/nvim-tree.renderer.components.padding.config.icons.glyphs.folder.empty_open +string/nvim-tree.renderer.components.padding.config.icons.glyphs.folder.symlink +string/nvim-tree.renderer.components.padding.config.icons.glyphs.folder.arrow_open +string/nvim-tree.renderer.components.padding.config.icons.glyphs.folder.symlink_open +string/nvim-tree.renderer.components.padding.config.icons.glyphs.bookmark +string/nvim-tree.renderer.components.padding.config.icons.glyphs.modified +string/nvim-tree.renderer.components.padding.config.icons.padding +string/nvim-tree.renderer.components.padding.config.icons.symlink_arrow +boolean/nvim-tree.renderer.components.padding.config.icons.show.folder +boolean/nvim-tree.renderer.components.padding.config.icons.show.folder_arrow +boolean/nvim-tree.renderer.components.padding.config.icons.show.git +boolean/nvim-tree.renderer.components.padding.config.icons.show.file +boolean/nvim-tree.renderer.components.padding.config.icons.show.modified +boolean/nvim-tree.renderer.components.padding.config.icons.webdev_colors +string/nvim-tree.renderer.components.padding.config.highlight_opened_files +boolean/nvim-tree.renderer.components.padding.config.modified.show_on_dirs +boolean/nvim-tree.renderer.components.padding.config.modified.enable +boolean/nvim-tree.renderer.components.padding.config.modified.show_on_open_dirs +boolean/nvim-tree.renderer.components.padding.config.add_trailing +boolean/nvim-tree.renderer.components.padding.config.group_empty +boolean/nvim-tree.renderer.components.padding.config.highlight_git +boolean/nvim-tree.renderer.components.padding.config.full_name +string/nvim-tree.renderer.components.padding.config.highlight_modified +string/nvim-tree.renderer.components.padding.config.root_folder_label +string/nvim-tree.renderer.components.padding.config.special_files.1 +string/nvim-tree.renderer.components.padding.config.special_files.2 +string/nvim-tree.renderer.components.padding.config.special_files.3 +string/nvim-tree.renderer.components.padding.config.special_files.4 +number/nvim-tree.renderer.components.padding.config.indent_width +function/5/nvim-tree.renderer.components.padding.get_padding +function/1/nvim-tree.renderer.components.padding.setup +function/1/nvim-tree.renderer.components.icons.setup +function/0/nvim-tree.renderer.components.icons.reset_config +function/0/nvim-tree.renderer.components.icons.devicons.get_icons +function/0/nvim-tree.renderer.components.icons.devicons.set_up_highlights +function/1/nvim-tree.renderer.components.icons.devicons.setup +function/0/nvim-tree.renderer.components.icons.devicons.has_loaded +function/1/nvim-tree.renderer.components.icons.devicons.get_icon_name_by_filetype +function/0/nvim-tree.renderer.components.icons.devicons.get_default_icon +function/2/nvim-tree.renderer.components.icons.devicons.get_icon_by_filetype +function/3/nvim-tree.renderer.components.icons.devicons.get_icon_colors +function/2/nvim-tree.renderer.components.icons.devicons.get_icon_colors_by_filetype +function/3/nvim-tree.renderer.components.icons.devicons.get_icon_color +function/2/nvim-tree.renderer.components.icons.devicons.get_icon_color_by_filetype +function/3/nvim-tree.renderer.components.icons.devicons.get_icon_cterm_color +function/2/nvim-tree.renderer.components.icons.devicons.get_icon_cterm_color_by_filetype +function/1/nvim-tree.renderer.components.icons.devicons.set_icon +function/3/nvim-tree.renderer.components.icons.devicons.set_default_icon +function/3/nvim-tree.renderer.components.icons.devicons.get_icon +function/1/nvim-tree.renderer.components.full-name.setup +number/nvim-tree.renderer.components.git.git_icons.DU.1.ord +string/nvim-tree.renderer.components.git.git_icons.DU.1.str +string/nvim-tree.renderer.components.git.git_icons.DU.1.hl +number/nvim-tree.renderer.components.git.git_icons.DU.2.ord +string/nvim-tree.renderer.components.git.git_icons.DU.2.str +string/nvim-tree.renderer.components.git.git_icons.DU.2.hl +number/nvim-tree.renderer.components.git.git_icons.dirty.1.ord +string/nvim-tree.renderer.components.git.git_icons.dirty.1.str +string/nvim-tree.renderer.components.git.git_icons.dirty.1.hl +number/nvim-tree.renderer.components.git.git_icons.!!.1.ord +string/nvim-tree.renderer.components.git.git_icons.!!.1.str +string/nvim-tree.renderer.components.git.git_icons.!!.1.hl +number/nvim-tree.renderer.components.git.git_icons.M .1.ord +string/nvim-tree.renderer.components.git.git_icons.M .1.str +string/nvim-tree.renderer.components.git.git_icons.M .1.hl +number/nvim-tree.renderer.components.git.git_icons. A.1.ord +string/nvim-tree.renderer.components.git.git_icons. A.1.str +string/nvim-tree.renderer.components.git.git_icons. A.1.hl +number/nvim-tree.renderer.components.git.git_icons.R .1.ord +string/nvim-tree.renderer.components.git.git_icons.R .1.str +string/nvim-tree.renderer.components.git.git_icons.R .1.hl +function/1/nvim-tree.renderer.components.git.setup +function/1/nvim-tree.renderer.components.git.setup_signs +function/0/nvim-tree.renderer.components.git.get_highlight +boolean/nvim-tree.renderer.components.git.git_show_on_open_dirs +function/1/nvim-tree.renderer.components.git.get_icons +function/4/luasnip.nodes.dynamicNode.D +function/1/nvim-tree.renderer.builder.unwrap +function/6/nvim-tree.renderer.builder._format_line +function/2/nvim-tree.renderer.builder.build_header +function/2/nvim-tree.renderer.builder._build_file_icon +function/2/nvim-tree.renderer.builder.configure_git_icons_placement +function/4/nvim-tree.renderer.builder._insert_highlight +function/2/nvim-tree.renderer.builder._insert_line +function/5/nvim-tree.renderer.builder._build_line +function/2/nvim-tree.renderer.builder._unwrap_highlighted_strings +function/2/nvim-tree.renderer.builder._get_nodes_number +function/2/nvim-tree.renderer.builder._build_folder +function/2/nvim-tree.renderer.builder.configure_root_label +function/2/nvim-tree.renderer.builder.configure_trailing_slash +function/2/nvim-tree.renderer.builder.configure_special_files +function/2/nvim-tree.renderer.builder.configure_picture_map +function/2/nvim-tree.renderer.builder.configure_opened_file_highlighting +function/2/nvim-tree.renderer.builder.configure_modified_highlighting +function/2/nvim-tree.renderer.builder.configure_icon_padding +function/2/nvim-tree.renderer.builder.configure_modified_placement +function/2/nvim-tree.renderer.builder.configure_symlink_destination +function/3/nvim-tree.renderer.builder.configure_filter +function/2/nvim-tree.renderer.builder._build_file +function/3/nvim-tree.renderer.builder.build +function/2/nvim-tree.renderer.builder._get_git_icons +function/2/nvim-tree.renderer.builder._get_modified_icon +function/2/nvim-tree.renderer.builder._build_symlink +function/3/nvim-tree.renderer.builder._get_highlight_override +function/1/nvim-tree.renderer.builder.new +number/vim.lsp.log.INFO +number/vim.lsp.log.DEBUG +number/vim.lsp.log.TRACE +function/0/vim.lsp.log.get_level +function/1/vim.lsp.log.set_format_func +function/1/vim.lsp.log.should_log +function/0/vim.lsp.log.warn +number/vim.lsp.log.WARN +number/vim.lsp.log.ERROR +function/1/vim.lsp.log.set_level +function/0/vim.lsp.log.get_filename +function/0/vim.lsp.log.debug +function/0/vim.lsp.log.trace +function/0/vim.lsp.log.info +function/0/vim.lsp.log.error +number/vim.lsp.log.OFF +function/0/lspconfig.server_configurations.clangd.commands.ClangdSwitchSourceHeader.1 +string/lspconfig.server_configurations.clangd.commands.ClangdSwitchSourceHeader.description +string/lspconfig.server_configurations.clangd.docs.default_config.root_dir +string/lspconfig.server_configurations.clangd.docs.default_config.capabilities +string/lspconfig.server_configurations.clangd.docs.description +function/1/lspconfig.server_configurations.clangd.default_config.root_dir +string/lspconfig.server_configurations.clangd.default_config.filetypes.1 +string/lspconfig.server_configurations.clangd.default_config.filetypes.2 +string/lspconfig.server_configurations.clangd.default_config.filetypes.3 +string/lspconfig.server_configurations.clangd.default_config.filetypes.4 +string/lspconfig.server_configurations.clangd.default_config.filetypes.5 +string/lspconfig.server_configurations.clangd.default_config.filetypes.6 +string/lspconfig.server_configurations.clangd.default_config.capabilities.offsetEncoding.1 +string/lspconfig.server_configurations.clangd.default_config.capabilities.offsetEncoding.2 +boolean/lspconfig.server_configurations.clangd.default_config.capabilities.textDocument.completion.editsNearCursor +boolean/lspconfig.server_configurations.clangd.default_config.single_file_support +string/lspconfig.server_configurations.clangd.default_config.cmd.1 +function/0/nvim-tree.marks.navigation.select +function/0/nvim-tree.marks.navigation.next +function/0/nvim-tree.marks.navigation.prev +function/7/vim.lsp.sync.compute_diff +function/1/cmp.utils.window.close +function/1/cmp.utils.window.get_content_height +function/3/cmp.utils.window.buffer_option +function/1/cmp.utils.window.update +function/1/cmp.utils.window.get_border_info +function/1/cmp.utils.window.visible +function/2/cmp.utils.window.open +function/1/cmp.utils.window.info +function/1/cmp.utils.window.get_buffer +function/2/cmp.utils.window.set_style +function/3/cmp.utils.window.option +function/0/cmp.utils.window.new +number/cmp.utils.buffer.cache.1 +number/cmp.utils.buffer.cache.3 +number/cmp.utils.buffer.cache.cmp.util.keymap.normalize +number/cmp.utils.buffer.cache.1thumb_buf +function/1/cmp.utils.buffer.get +function/1/cmp.utils.buffer.ensure +boolean/nvim-tree.lib.respect_buf_cwd +function/5/nvim-tree.lib.prompt +boolean/nvim-tree.lib.select_prompts +function/0/nvim-tree.lib.reload_git +function/0/nvim-tree.lib.set_target_win +function/1/nvim-tree.lib.dir_up +function/2/nvim-tree.lib.change_dir +function/1/nvim-tree.lib.set_index_and_redraw +function/1/nvim-tree.lib.collapse_all +boolean/nvim-tree.lib.hijack_directories.auto_open +boolean/nvim-tree.lib.hijack_directories.enable +function/0/nvim-tree.lib.get_nodes +function/1/nvim-tree.lib.get_last_group_node +function/1/nvim-tree.lib.open +function/1/nvim-tree.lib.expand_or_collapse +function/0/nvim-tree.lib.get_node_at_cursor +function/1/nvim-tree.lib.setup +function/2/nvim-tree.lib.refresh_tree +boolean/nvim-tree.lib.hijack_unnamed_buffer_when_opening +boolean/nvim-tree.log.config.enable +boolean/nvim-tree.log.config.types.copy_paste +boolean/nvim-tree.log.config.types.config +boolean/nvim-tree.log.config.types.git +boolean/nvim-tree.log.config.types.diagnostics +boolean/nvim-tree.log.config.types.all +boolean/nvim-tree.log.config.types.dev +boolean/nvim-tree.log.config.types.profile +boolean/nvim-tree.log.config.types.watcher +boolean/nvim-tree.log.config.truncate +function/1/nvim-tree.log.setup +function/1/nvim-tree.log.enabled +function/1/nvim-tree.log.profile_start +function/2/nvim-tree.log.raw +function/2/nvim-tree.log.line +function/1/nvim-tree.log.profile_end +function/0/nvim-tree.colors.setup +function/2/nvim-tree.renderer.render_hl +function/1/nvim-tree.renderer.setup +function/1/nvim-tree.renderer.draw +function/0/nvim-tree.view.reposition_window +function/0/nvim-tree.view.abandon_current_window +function/1/nvim-tree.view.toggle_help +function/1/nvim-tree.view.get_winnr +function/0/nvim-tree.view.abandon_all_windows +function/0/nvim-tree.view.close_this_tab_only +function/0/nvim-tree.view.restore_tab_state +function/1/nvim-tree.view.is_root_folder_visible +string/nvim-tree.view.on_attach +function/1/nvim-tree.view.setup +function/1/nvim-tree.view.is_help_ui +function/0/nvim-tree.view.close +function/0/nvim-tree.view._prevent_buffer_override +function/1/nvim-tree.view.is_visible +function/1/nvim-tree.view.is_buf_valid +boolean/nvim-tree.view.View.centralize_selection +boolean/nvim-tree.view.View.tab.sync.open +boolean/nvim-tree.view.View.tab.sync.close +number/nvim-tree.view.View.width +boolean/nvim-tree.view.View.hide_root_folder +string/nvim-tree.view.View.side +boolean/nvim-tree.view.View.preserve_window_proportions +boolean/nvim-tree.view.View.float.quit_on_focus_loss +string/nvim-tree.view.View.float.open_win_config.relative +string/nvim-tree.view.View.float.open_win_config.border +number/nvim-tree.view.View.float.open_win_config.row +number/nvim-tree.view.View.float.open_win_config.height +number/nvim-tree.view.View.float.open_win_config.width +number/nvim-tree.view.View.float.open_win_config.col +boolean/nvim-tree.view.View.float.enable +number/nvim-tree.view.View.initial_width +boolean/nvim-tree.view.View.adaptive_size +boolean/nvim-tree.view.View.winopts.number +string/nvim-tree.view.View.winopts.winhl +string/nvim-tree.view.View.winopts.colorcolumn +boolean/nvim-tree.view.View.winopts.wrap +string/nvim-tree.view.View.winopts.cursorlineopt +boolean/nvim-tree.view.View.winopts.spell +boolean/nvim-tree.view.View.winopts.foldenable +boolean/nvim-tree.view.View.winopts.winfixwidth +boolean/nvim-tree.view.View.winopts.winfixheight +string/nvim-tree.view.View.winopts.foldmethod +boolean/nvim-tree.view.View.winopts.cursorline +boolean/nvim-tree.view.View.winopts.relativenumber +string/nvim-tree.view.View.winopts.signcolumn +boolean/nvim-tree.view.View.winopts.cursorcolumn +string/nvim-tree.view.View.winopts.foldcolumn +boolean/nvim-tree.view.View.winopts.list +function/0/nvim-tree.view.reset_winhl +function/1/nvim-tree.view.open_in_current_win +function/0/nvim-tree.view.get_bufnr +function/1/nvim-tree.view.resize +function/1/nvim-tree.view.open +function/0/nvim-tree.view.grow_from_content +function/1/nvim-tree.view.set_cursor +function/2/nvim-tree.view.focus +function/0/nvim-tree.view.close_all_tabs +function/3/nvim-tree.utils.debounce +function/2/nvim-tree.utils.str_find +function/2/nvim-tree.utils.table_create_missing +function/2/nvim-tree.utils.path_relative +function/7/nvim-tree.utils.move_missing_val +function/1/nvim-tree.utils.format_bytes +function/1/nvim-tree.utils.get_node_from_path +function/2/nvim-tree.utils.key_by +boolean/nvim-tree.utils.is_unix +boolean/nvim-tree.utils.is_macos +function/2/nvim-tree.utils.bool_record +boolean/nvim-tree.utils.is_wsl +boolean/nvim-tree.utils.is_windows +function/1/nvim-tree.utils.focus_file +function/1/nvim-tree.utils.canonical_path +function/1/nvim-tree.utils.get_win_buf_from_path +function/1/nvim-tree.utils.read_file +function/1/nvim-tree.utils.array_shallow_clone +function/2/nvim-tree.utils.array_remove +function/1/nvim-tree.utils.path_split +function/1/nvim-tree.utils.inject_node +function/1/nvim-tree.utils.path_basename +function/1/nvim-tree.utils.is_nvim_tree_buf +function/1/nvim-tree.utils.array_remove_nils +function/1/nvim-tree.utils.path_add_trailing +function/0/nvim-tree.utils.clear_prompt +function/2/nvim-tree.utils.find_node +function/1/nvim-tree.utils.path_join +function/1/nvim-tree.utils.get_parent_of_group +function/2/nvim-tree.utils.get_nodes_by_line +function/1/nvim-tree.utils.file_exists +function/1/nvim-tree.utils.path_remove_trailing +function/2/nvim-tree.utils.rename_loaded_buffers +string/nvim-tree.utils.path_separator +number/nvim-tree.actions.root.change-dir.current_tab +function/1/nvim-tree.actions.root.change-dir.setup +boolean/nvim-tree.actions.root.change-dir.options.global +boolean/nvim-tree.actions.root.change-dir.options.enable +boolean/nvim-tree.actions.root.change-dir.options.restrict_above_cwd +function/2/nvim-tree.actions.root.change-dir.force_dirchange +function/2/nvim-tree.actions.root.change-dir.fn +function/1/nvim-tree.legacy.migrate_legacy_options +function/0/jit.opt.start +function/1/luasnip.util.parser.neovim_parser.parse +function/2/luasnip.util.parser.neovim_parser.ast.text +function/2/luasnip.util.parser.neovim_parser.ast.choice +number/luasnip.util.parser.neovim_parser.ast.node_type.TABSTOP +number/luasnip.util.parser.neovim_parser.ast.node_type.PLACEHOLDER +number/luasnip.util.parser.neovim_parser.ast.node_type.VARIABLE +number/luasnip.util.parser.neovim_parser.ast.node_type.CHOICE +number/luasnip.util.parser.neovim_parser.ast.node_type.TRANSFORM +number/luasnip.util.parser.neovim_parser.ast.node_type.FORMAT +number/luasnip.util.parser.neovim_parser.ast.node_type.TEXT +number/luasnip.util.parser.neovim_parser.ast.node_type.SNIPPET +function/2/luasnip.util.parser.neovim_parser.ast.tabstop +function/3/luasnip.util.parser.neovim_parser.ast.transform +function/2/luasnip.util.parser.neovim_parser.ast.format +function/2/luasnip.util.parser.neovim_parser.ast.placeholder +function/2/luasnip.util.parser.neovim_parser.ast.variable +function/1/luasnip.util.parser.neovim_parser.ast.snippet +function/1/luasnip.util.parser.neovim_parser.ast.is_node +function/1/luasnip.util.parser.neovim_parser.ast.merge_adjacent_text +function/0/ffi.fill +function/0/ffi.abi +string/ffi.os +function/0/ffi.load +function/0/ffi.string +string/ffi.arch +function/0/ffi.metatype +function/0/ffi.copy +function/0/ffi.sizeof +function/0/ffi.errno +function/0/ffi.gc +userdata/ffi.C +function/0/ffi.cdef +function/0/ffi.cast +function/0/ffi.typeof +function/0/ffi.typeinfo +function/0/ffi.istype +function/0/ffi.alignof +function/0/ffi.offsetof +function/0/ffi.new +function/2/which-key.text.fix_nl +function/5/which-key.text.set +function/5/which-key.text.highlight +function/1/which-key.text.nl +function/1/which-key.text.len +function/1/which-key.text.new +number/which-key.config.namespace +function/1/which-key.config.setup +string/which-key.config.options.popup_mappings.scroll_down +string/which-key.config.options.popup_mappings.scroll_up +string/which-key.config.options.hidden.1 +string/which-key.config.options.hidden.2 +string/which-key.config.options.hidden.3 +string/which-key.config.options.hidden.4 +string/which-key.config.options.hidden.5 +string/which-key.config.options.hidden.6 +string/which-key.config.options.hidden.7 +string/which-key.config.options.hidden.8 +string/which-key.config.options.window.position +number/which-key.config.options.window.margin.1 +number/which-key.config.options.window.margin.2 +number/which-key.config.options.window.margin.3 +number/which-key.config.options.window.margin.4 +number/which-key.config.options.window.winblend +string/which-key.config.options.window.border +number/which-key.config.options.window.padding.1 +number/which-key.config.options.window.padding.2 +number/which-key.config.options.window.padding.3 +number/which-key.config.options.window.padding.4 +string/which-key.config.options.operators.d +string/which-key.config.options.operators.g~ +string/which-key.config.options.operators.! +string/which-key.config.options.operators.v +string/which-key.config.options.operators.gu +string/which-key.config.options.operators.c +string/which-key.config.options.operators.gU +string/which-key.config.options.operators. +string/which-key.config.options.operators.> +string/which-key.config.options.operators.gc +string/which-key.config.options.operators.y +string/which-key.config.options.operators.zf +string/which-key.config.options.layout.align +number/which-key.config.options.layout.height.max +number/which-key.config.options.layout.height.min +number/which-key.config.options.layout.width.max +number/which-key.config.options.layout.width.min +number/which-key.config.options.layout.spacing +boolean/which-key.config.options.motions.count +boolean/which-key.config.options.ignore_missing +string/which-key.config.options.icons.separator +string/which-key.config.options.icons.breadcrumb +string/which-key.config.options.icons.group +string/which-key.config.options.triggers_nowait.1 +string/which-key.config.options.triggers_nowait.2 +string/which-key.config.options.triggers_nowait.3 +string/which-key.config.options.triggers_nowait.4 +string/which-key.config.options.triggers_nowait.5 +string/which-key.config.options.triggers_nowait.6 +string/which-key.config.options.triggers_nowait.7 +string/which-key.config.options.triggers_nowait.8 +string/which-key.config.options.triggers_blacklist.v.1 +string/which-key.config.options.triggers_blacklist.v.2 +string/which-key.config.options.triggers_blacklist.i.1 +string/which-key.config.options.triggers_blacklist.i.2 +string/which-key.config.options.triggers +boolean/which-key.config.options.plugins.registers +boolean/which-key.config.options.plugins.presets.enabled +boolean/which-key.config.options.plugins.presets.g +boolean/which-key.config.options.plugins.presets.text_objects +boolean/which-key.config.options.plugins.presets.nav +boolean/which-key.config.options.plugins.presets.operators +boolean/which-key.config.options.plugins.presets.windows +boolean/which-key.config.options.plugins.presets.z +boolean/which-key.config.options.plugins.presets.motions +boolean/which-key.config.options.plugins.marks +number/which-key.config.options.plugins.spelling.suggestions +boolean/which-key.config.options.plugins.spelling.enabled +boolean/which-key.config.options.show_help +boolean/which-key.config.options.show_keys +function/4/luasnip.util.functions.var +function/1/luasnip.util.functions.copy +function/1/luasnip.util.functions.better_var +function/1/luasnip.util.functions.eval_vim_dynamic +string/which-key.plugins.presets.misc.name +function/2/which-key.plugins.presets.misc.setup +string/lspconfig.server_configurations.pylsp.docs.description +function/1/lspconfig.server_configurations.pylsp.default_config.root_dir +string/lspconfig.server_configurations.pylsp.default_config.cmd.1 +boolean/lspconfig.server_configurations.pylsp.default_config.single_file_support +string/lspconfig.server_configurations.pylsp.default_config.filetypes.1 +function/1/which-key.layout.trail +function/2/which-key.layout.layout +function/2/which-key.layout.max_width +function/3/which-key.layout.new +string/which-key.view.keys +function/0/which-key.view.getchar +function/0/which-key.view.back +function/0/which-key.view.hide +boolean/which-key.view.auto +string/which-key.view.reg +function/1/which-key.view.scroll +function/0/which-key.view.show +number/which-key.view.win +function/1/which-key.view.on_keys +function/1/which-key.view.is_enabled +function/0/which-key.view.is_valid +number/which-key.view.count +function/1/which-key.view.render +function/0/which-key.view.show_cursor +function/1/which-key.view.has_cmd +function/2/which-key.view.open +function/3/which-key.view.execute +function/0/which-key.view.read_pending +function/0/which-key.view.hide_cursor +string/which-key.view.mode +function/0/which-key.view.on_close +string/lspkind.presets.default.Property +string/lspkind.presets.default.Unit +string/lspkind.presets.default.Value +string/lspkind.presets.default.Enum +string/lspkind.presets.default.Color +string/lspkind.presets.default.Function +string/lspkind.presets.default.Reference +string/lspkind.presets.default.Folder +string/lspkind.presets.default.EnumMember +string/lspkind.presets.default.Struct +string/lspkind.presets.default.Operator +string/lspkind.presets.default.Keyword +string/lspkind.presets.default.TypeParameter +string/lspkind.presets.default.Event +string/lspkind.presets.default.Constant +string/lspkind.presets.default.File +string/lspkind.presets.default.Snippet +string/lspkind.presets.default.Text +string/lspkind.presets.default.Method +string/lspkind.presets.default.Constructor +string/lspkind.presets.default.Field +string/lspkind.presets.default.Variable +string/lspkind.presets.default.Class +string/lspkind.presets.default.Interface +string/lspkind.presets.default.Module +string/lspkind.presets.codicons.Property +string/lspkind.presets.codicons.Unit +string/lspkind.presets.codicons.Value +string/lspkind.presets.codicons.Enum +string/lspkind.presets.codicons.Color +string/lspkind.presets.codicons.Function +string/lspkind.presets.codicons.Reference +string/lspkind.presets.codicons.Folder +string/lspkind.presets.codicons.EnumMember +string/lspkind.presets.codicons.Struct +string/lspkind.presets.codicons.Operator +string/lspkind.presets.codicons.Keyword +string/lspkind.presets.codicons.TypeParameter +string/lspkind.presets.codicons.Event +string/lspkind.presets.codicons.Constant +string/lspkind.presets.codicons.File +string/lspkind.presets.codicons.Snippet +string/lspkind.presets.codicons.Text +string/lspkind.presets.codicons.Method +string/lspkind.presets.codicons.Constructor +string/lspkind.presets.codicons.Field +string/lspkind.presets.codicons.Variable +string/lspkind.presets.codicons.Class +string/lspkind.presets.codicons.Interface +string/lspkind.presets.codicons.Module +function/2/lspkind.symbolic +function/1/lspkind.cmp_format +function/1/lspkind.init +boolean/nvim-tree.marks.bulk-move.enable_reload +function/0/nvim-tree.marks.bulk-move.bulk_move +function/1/nvim-tree.marks.bulk-move.setup +function/0/which-key.colors.setup +function/3/cmp.utils.options.buf_set_option +function/3/cmp.utils.options.win_set_option +number/luasnip.session.snippet_collection.invalidated_count +function/1/luasnip.session.snippet_collection.get_id_snippet +function/1/luasnip.session.snippet_collection.clear_snippets +function/1/luasnip.session.snippet_collection.clean_invalidated +function/2/luasnip.session.snippet_collection.get_snippets +function/2/luasnip.session.snippet_collection.add_snippets +function/3/luasnip.session.snippet_collection.match_snippet +string/which-key.plugins.presets.objects.i) +string/which-key.plugins.presets.objects.i +string/which-key.plugins.presets.objects.i> +string/which-key.plugins.presets.objects.iB +string/which-key.plugins.presets.objects.a.name +string/which-key.plugins.presets.objects.iW +string/which-key.plugins.presets.objects.i[ +string/which-key.plugins.presets.objects.i] +string/which-key.plugins.presets.objects.i` +string/which-key.plugins.presets.objects.ib +string/which-key.plugins.presets.objects.ip +string/which-key.plugins.presets.objects.is +string/which-key.plugins.presets.objects.it +string/which-key.plugins.presets.objects.i{ +string/which-key.plugins.presets.objects.a" +string/which-key.plugins.presets.objects.a' +string/which-key.plugins.presets.objects.a( +string/which-key.plugins.presets.objects.at +string/which-key.plugins.presets.objects.a) +string/which-key.plugins.presets.objects.a +string/which-key.plugins.presets.objects.a> +string/which-key.plugins.presets.objects.aB +string/which-key.plugins.presets.objects.aW +string/which-key.plugins.presets.objects.a[ +string/which-key.plugins.presets.objects.a] +string/which-key.plugins.presets.objects.a` +string/which-key.plugins.presets.objects.ab +string/which-key.plugins.presets.objects.ap +string/which-key.plugins.presets.objects.aw +string/which-key.plugins.presets.objects.a{ +string/which-key.plugins.presets.objects.i} +string/which-key.plugins.presets.objects.a} +string/which-key.plugins.presets.objects.i" +string/which-key.plugins.presets.objects.iw +string/which-key.plugins.presets.objects.i' +string/which-key.plugins.presets.objects.i.name +string/which-key.plugins.presets.objects.i( +string/which-key.plugins.presets.objects.as +string/which-key.plugins.presets.name +string/which-key.plugins.presets.operators.d +string/which-key.plugins.presets.operators.g~ +string/which-key.plugins.presets.operators.v +string/which-key.plugins.presets.operators.gu +string/which-key.plugins.presets.operators.c +string/which-key.plugins.presets.operators.gU +string/which-key.plugins.presets.operators.! +string/which-key.plugins.presets.operators.> +string/which-key.plugins.presets.operators. +string/which-key.plugins.presets.operators.y +string/which-key.plugins.presets.operators.zf +function/3/which-key.plugins.presets.setup +string/which-key.plugins.presets.motions.^ +string/which-key.plugins.presets.motions.F +string/which-key.plugins.presets.motions.j +string/which-key.plugins.presets.motions.} +string/which-key.plugins.presets.motions.ge +string/which-key.plugins.presets.motions.b +string/which-key.plugins.presets.motions.k +string/which-key.plugins.presets.motions.l +string/which-key.plugins.presets.motions.gg +string/which-key.plugins.presets.motions.e +string/which-key.plugins.presets.motions.$ +string/which-key.plugins.presets.motions.% +string/which-key.plugins.presets.motions.{ +string/which-key.plugins.presets.motions.f +string/which-key.plugins.presets.motions.T +string/which-key.plugins.presets.motions.G +string/which-key.plugins.presets.motions.0 +string/which-key.plugins.presets.motions.h +string/which-key.plugins.presets.motions.w +string/which-key.plugins.presets.motions.t +function/3/which-key.mappings._parse +function/1/which-key.mappings.child_opts +function/2/which-key.mappings._process +function/3/which-key.mappings._try_parse +function/2/which-key.mappings.parse +function/1/which-key.mappings.to_mapping +function/0/nvim-tree.core.get_nodes_starting_line +function/0/nvim-tree.core.get_cwd +function/0/nvim-tree.core.get_explorer +function/1/nvim-tree.core.init +function/0/string.sub +function/0/string.rep +function/0/string.reverse +function/0/string.lower +function/0/string.upper +function/0/string.dump +function/0/string.find +function/0/string.match +function/0/string.gmatch +function/0/string.gsub +function/0/string.format +function/1/string.len +function/0/string.byte +function/0/string.char +function/2/which-key.plugins.invoke +string/which-key.plugins.plugins.registers.name +function/3/which-key.plugins.plugins.registers.setup +string/which-key.plugins.plugins.registers.actions.1.trigger +string/which-key.plugins.plugins.registers.actions.1.mode +string/which-key.plugins.plugins.registers.actions.2.trigger +string/which-key.plugins.plugins.registers.actions.2.mode +string/which-key.plugins.plugins.registers.actions.3.trigger +boolean/which-key.plugins.plugins.registers.actions.3.delay +string/which-key.plugins.plugins.registers.actions.3.mode +string/which-key.plugins.plugins.registers.actions.4.trigger +string/which-key.plugins.plugins.registers.actions.4.mode +string/which-key.plugins.plugins.registers.actions.5.trigger +string/which-key.plugins.plugins.registers.actions.5.mode +string/which-key.plugins.plugins.registers.registers +function/3/which-key.plugins.plugins.registers.run +function/3/which-key.plugins.plugins.marks.setup +string/which-key.plugins.plugins.marks.actions.1.trigger +string/which-key.plugins.plugins.marks.actions.1.mode +string/which-key.plugins.plugins.marks.actions.2.trigger +string/which-key.plugins.plugins.marks.actions.2.mode +string/which-key.plugins.plugins.marks.actions.3.trigger +string/which-key.plugins.plugins.marks.actions.3.mode +string/which-key.plugins.plugins.marks.actions.4.trigger +string/which-key.plugins.plugins.marks.actions.4.mode +string/which-key.plugins.plugins.marks.name +function/3/which-key.plugins.plugins.marks.run +function/0/which-key.plugins.setup +function/2/which-key.plugins._setup +number/nvim-tree.actions.tree-modifiers.expand-all.MAX_FOLDER_DISCOVERY +function/1/nvim-tree.actions.tree-modifiers.expand-all.setup +function/1/nvim-tree.actions.tree-modifiers.expand-all.fn +function/2/luasnip.loaders.util.ft_filter +function/1/luasnip.loaders.util.get_load_fts +function/3/luasnip.loaders.util.get_load_paths_snipmate_like +function/1/luasnip.loaders.util.edit_snippet_files +function/1/luasnip.loaders.util.filetypelist_to_set +function/1/luasnip.loaders.util.split_lines +function/2/luasnip.loaders.util.extend_ft_paths +function/1/luasnip.loaders.util.add_opts +function/2/luasnip.loaders.util.get_ft_paths +function/2/luasnip.loaders.util.normalize_paths +function/0/nvim-tree.actions.tree-modifiers.toggles.git_clean +function/0/nvim-tree.actions.tree-modifiers.toggles.no_buffer +function/0/nvim-tree.actions.tree-modifiers.toggles.custom +function/0/nvim-tree.actions.tree-modifiers.toggles.help +function/0/nvim-tree.actions.tree-modifiers.toggles.dotfiles +function/0/nvim-tree.actions.tree-modifiers.toggles.git_ignored +function/0/luasnip.util.directed_graph.new +function/3/luasnip.nodes.choiceNode.C +boolean/nvim-tree.actions.fs.copy-paste.enable_reload +function/1/nvim-tree.actions.fs.copy-paste.copy_absolute_path +function/1/nvim-tree.actions.fs.copy-paste.copy +boolean/nvim-tree.actions.fs.copy-paste.use_system_clipboard +function/0/nvim-tree.actions.fs.copy-paste.clear_clipboard +function/1/nvim-tree.actions.fs.copy-paste.setup +function/1/nvim-tree.actions.fs.copy-paste.cut +function/1/nvim-tree.actions.fs.copy-paste.paste +function/0/nvim-tree.actions.fs.copy-paste.print_clipboard +function/1/nvim-tree.actions.fs.copy-paste.copy_filename +function/1/nvim-tree.actions.fs.copy-paste.copy_path +function/3/luasnip.nodes.functionNode.F +function/1/luasnip.nodes.functionNode.FunctionNode.get_docstring +boolean/luasnip.nodes.functionNode.FunctionNode.merge_node_ext_opts +function/1/luasnip.nodes.functionNode.FunctionNode.is_interactive +boolean/luasnip.nodes.functionNode.FunctionNode.visible +function/2/luasnip.nodes.functionNode.FunctionNode.make_args_absolute +function/1/luasnip.nodes.functionNode.FunctionNode.get_static_text +boolean/luasnip.nodes.functionNode.FunctionNode.static_visible +function/2/luasnip.nodes.functionNode.FunctionNode.put_initial +function/1/luasnip.nodes.functionNode.FunctionNode.update_restore +function/2/luasnip.nodes.functionNode.FunctionNode.indent +function/3/luasnip.nodes.functionNode.FunctionNode.input_enter +function/1/luasnip.nodes.functionNode.FunctionNode.set_dependents +number/luasnip.nodes.functionNode.FunctionNode.node_ext_opts.base_prio +function/2/luasnip.nodes.functionNode.FunctionNode.expand_tabs +function/1/luasnip.nodes.functionNode.FunctionNode.update_static +function/1/luasnip.nodes.functionNode.FunctionNode.update +boolean/luasnip.nodes.functionNode.FunctionNode.visited +boolean/nvim-tree.actions.fs.create-file.enable_reload +function/1/nvim-tree.actions.fs.create-file.setup +function/1/nvim-tree.actions.fs.create-file.fn +boolean/nvim-tree.git.config.git.ignore +number/nvim-tree.git.config.git.timeout +boolean/nvim-tree.git.config.git.show_on_dirs +boolean/nvim-tree.git.config.git.show_on_open_dirs +boolean/nvim-tree.git.config.git.enable +boolean/nvim-tree.git.config.filesystem_watchers.enable +number/nvim-tree.git.config.filesystem_watchers.debounce_delay +function/1/nvim-tree.git.setup +function/1/nvim-tree.git.get_project_root +function/0/nvim-tree.git.purge_state +function/0/nvim-tree.git.disable_git_integration +function/2/nvim-tree.git.reload_project +function/0/nvim-tree.git.reload +function/1/nvim-tree.git.get_project +function/1/nvim-tree.git.load_project_status +function/1/nvim-tree.api.node.navigate.sibling.prev +function/1/nvim-tree.api.node.navigate.sibling.first +function/1/nvim-tree.api.node.navigate.sibling.next +function/1/nvim-tree.api.node.navigate.sibling.last +function/1/nvim-tree.api.node.navigate.parent_close +function/1/nvim-tree.api.node.navigate.git.next +function/1/nvim-tree.api.node.navigate.git.prev +function/1/nvim-tree.api.node.navigate.parent +function/1/nvim-tree.api.node.navigate.diagnostics.next +function/1/nvim-tree.api.node.navigate.diagnostics.prev +function/1/nvim-tree.api.node.show_info_popup +function/1/nvim-tree.api.node.open.edit +function/1/nvim-tree.api.node.open.replace_tree_buffer +function/1/nvim-tree.api.node.open.no_window_picker +function/1/nvim-tree.api.node.open.preview +function/1/nvim-tree.api.node.open.vertical +function/1/nvim-tree.api.node.open.horizontal +function/1/nvim-tree.api.node.open.tab +function/1/nvim-tree.api.node.run.system +function/1/nvim-tree.api.node.run.cmd +function/0/nvim-tree.api.config.mappings.default +function/0/nvim-tree.api.config.mappings.active +function/0/nvim-tree.api.marks.list +function/0/nvim-tree.api.marks.bulk.move +function/0/nvim-tree.api.marks.clear +function/1/nvim-tree.api.marks.get +function/1/nvim-tree.api.marks.toggle +function/0/nvim-tree.api.marks.navigate.select +function/0/nvim-tree.api.marks.navigate.next +function/0/nvim-tree.api.marks.navigate.prev +function/1/nvim-tree.api.fs.create +function/1/nvim-tree.api.fs.copy.node +function/1/nvim-tree.api.fs.copy.absolute_path +function/1/nvim-tree.api.fs.copy.relative_path +function/1/nvim-tree.api.fs.copy.filename +function/1/nvim-tree.api.fs.rename +function/0/nvim-tree.api.fs.print_clipboard +function/1/nvim-tree.api.fs.rename_basename +function/0/nvim-tree.api.fs.clear_clipboard +function/1/nvim-tree.api.fs.cut +function/1/nvim-tree.api.fs.remove +function/1/nvim-tree.api.fs.paste +function/1/nvim-tree.api.fs.trash +function/1/nvim-tree.api.fs.rename_node +function/1/nvim-tree.api.fs.rename_sub +function/0/nvim-tree.api.git.reload +string/nvim-tree.api.events.Event.FolderRemoved +string/nvim-tree.api.events.Event.Resize +string/nvim-tree.api.events.Event.TreeAttachedPost +string/nvim-tree.api.events.Event.Ready +string/nvim-tree.api.events.Event.WillRenameNode +string/nvim-tree.api.events.Event.NodeRenamed +string/nvim-tree.api.events.Event.TreeOpen +string/nvim-tree.api.events.Event.TreeClose +string/nvim-tree.api.events.Event.FileCreated +string/nvim-tree.api.events.Event.FileRemoved +string/nvim-tree.api.events.Event.FolderCreated +function/2/nvim-tree.api.events.subscribe +function/1/nvim-tree.api.tree.change_root_to_node +function/0/nvim-tree.api.tree.toggle_help +function/1/nvim-tree.api.tree.expand_all +function/0/nvim-tree.api.tree.close +function/1/nvim-tree.api.tree.open +function/0/nvim-tree.api.tree.toggle_no_buffer_filter +function/4/nvim-tree.api.tree.toggle +function/0/nvim-tree.api.tree.toggle_gitignore_filter +function/1/nvim-tree.api.tree.collapse_all +function/1/nvim-tree.api.tree.change_root +function/1/nvim-tree.api.tree.find_file +function/0/nvim-tree.api.tree.get_nodes +function/0/nvim-tree.api.tree.close_in_this_tab +function/0/nvim-tree.api.tree.close_in_all_tabs +function/0/nvim-tree.api.tree.get_node_under_cursor +function/0/nvim-tree.api.tree.toggle_git_clean_filter +function/0/nvim-tree.api.tree.search_node +function/0/nvim-tree.api.tree.toggle_hidden_filter +function/0/nvim-tree.api.tree.toggle_custom_filter +function/2/nvim-tree.api.tree.reload +function/0/nvim-tree.api.tree.focus +function/1/nvim-tree.api.tree.change_root_to_parent +function/0/nvim-tree.api.live_filter.clear +function/0/nvim-tree.api.live_filter.start +string/nvim-tree.actions.fs.trash.config.trash.cmd +boolean/nvim-tree.actions.fs.trash.config.ui.confirm.trash +boolean/nvim-tree.actions.fs.trash.config.ui.confirm.remove +boolean/nvim-tree.actions.fs.trash.enable_reload +function/1/nvim-tree.actions.fs.trash.setup +function/1/nvim-tree.actions.fs.trash.fn +function/1/nvim-tree.actions.fs.remove-file.setup +boolean/nvim-tree.actions.fs.remove-file.close_window +boolean/nvim-tree.actions.fs.remove-file.enable_reload +function/1/nvim-tree.actions.fs.remove-file.fn +function/1/nvim-tree.modified.setup +function/0/nvim-tree.modified.reload +function/1/nvim-tree.modified.is_modified +function/0/cmp.mapping.close +function/1/cmp.mapping.select_next_item +function/1/cmp.mapping.select_prev_item +function/1/cmp.mapping.complete +function/1/cmp.mapping.scroll_docs +function/1/cmp.mapping.preset.insert +function/1/cmp.mapping.preset.cmdline +function/0/cmp.mapping.complete_common_string +function/0/cmp.mapping.abort +function/1/cmp.mapping.confirm +function/1/cmp.setup.global +function/2/cmp.setup.filetype +function/2/cmp.setup.cmdline +function/1/cmp.setup.buffer +function/0/cmp.suspend +function/2/cmp.register_source +function/1/cmp.unregister_source +function/0/cmp.complete +boolean/cmp.vim +boolean/cmp.core.suspending +boolean/cmp.core.sources.1.incomplete +string/cmp.core.sources.1.name +string/cmp.core.sources.1.context.cursor_line +number/cmp.core.sources.1.context.id +string/cmp.core.sources.1.context.filetype +number/cmp.core.sources.1.context.time +number/cmp.core.sources.1.context.bufnr +string/cmp.core.sources.1.context.cursor_after_line +string/cmp.core.sources.1.context.input +string/cmp.core.sources.1.context.cursor_before_line +number/cmp.core.sources.1.context.cursor.row +number/cmp.core.sources.1.context.cursor.col +number/cmp.core.sources.1.id +function/1/cmp.core.sources.1.complete_dedup +number/cmp.core.sources.1.revision +number/cmp.core.sources.1.request_offset +number/cmp.core.sources.1.status +number/cmp.core.sources.1.offset +boolean/cmp.core.sources.1.is_triggered_by_symbol +boolean/cmp.core.sources.2.incomplete +string/cmp.core.sources.2.name +string/cmp.core.sources.2.context.cursor_line +number/cmp.core.sources.2.context.id +string/cmp.core.sources.2.context.filetype +number/cmp.core.sources.2.context.time +number/cmp.core.sources.2.context.bufnr +string/cmp.core.sources.2.context.cursor_after_line +string/cmp.core.sources.2.context.input +string/cmp.core.sources.2.context.cursor_before_line +number/cmp.core.sources.2.context.cursor.row +number/cmp.core.sources.2.context.cursor.col +number/cmp.core.sources.2.id +function/1/cmp.core.sources.2.complete_dedup +number/cmp.core.sources.2.revision +string/cmp.core.sources.2.source.client.config.cmd_cwd +function/2/cmp.core.sources.2.source.client.config.on_init +boolean/cmp.core.sources.2.source.client.config.capabilities.window.workDoneProgress +boolean/cmp.core.sources.2.source.client.config.capabilities.window.showMessage.messageActionItem.additionalPropertiesSupport +boolean/cmp.core.sources.2.source.client.config.capabilities.window.showDocument.support +boolean/cmp.core.sources.2.source.client.config.capabilities.workspace.applyEdit +string/cmp.core.sources.2.source.client.config.capabilities.workspace.workspaceEdit.resourceOperations.1 +string/cmp.core.sources.2.source.client.config.capabilities.workspace.workspaceEdit.resourceOperations.2 +string/cmp.core.sources.2.source.client.config.capabilities.workspace.workspaceEdit.resourceOperations.3 +boolean/cmp.core.sources.2.source.client.config.capabilities.workspace.workspaceFolders +boolean/cmp.core.sources.2.source.client.config.capabilities.workspace.configuration +boolean/cmp.core.sources.2.source.client.config.capabilities.workspace.symbol.dynamicRegistration +boolean/cmp.core.sources.2.source.client.config.capabilities.workspace.symbol.hierarchicalWorkspaceSymbolSupport +number/cmp.core.sources.2.source.client.config.capabilities.workspace.symbol.symbolKind.valueSet.1 +number/cmp.core.sources.2.source.client.config.capabilities.workspace.symbol.symbolKind.valueSet.2 +number/cmp.core.sources.2.source.client.config.capabilities.workspace.symbol.symbolKind.valueSet.3 +number/cmp.core.sources.2.source.client.config.capabilities.workspace.symbol.symbolKind.valueSet.4 +number/cmp.core.sources.2.source.client.config.capabilities.workspace.symbol.symbolKind.valueSet.5 +number/cmp.core.sources.2.source.client.config.capabilities.workspace.symbol.symbolKind.valueSet.6 +number/cmp.core.sources.2.source.client.config.capabilities.workspace.symbol.symbolKind.valueSet.7 +number/cmp.core.sources.2.source.client.config.capabilities.workspace.symbol.symbolKind.valueSet.8 +number/cmp.core.sources.2.source.client.config.capabilities.workspace.symbol.symbolKind.valueSet.9 +number/cmp.core.sources.2.source.client.config.capabilities.workspace.symbol.symbolKind.valueSet.10 +number/cmp.core.sources.2.source.client.config.capabilities.workspace.symbol.symbolKind.valueSet.11 +number/cmp.core.sources.2.source.client.config.capabilities.workspace.symbol.symbolKind.valueSet.12 +number/cmp.core.sources.2.source.client.config.capabilities.workspace.symbol.symbolKind.valueSet.13 +number/cmp.core.sources.2.source.client.config.capabilities.workspace.symbol.symbolKind.valueSet.14 +number/cmp.core.sources.2.source.client.config.capabilities.workspace.symbol.symbolKind.valueSet.15 +number/cmp.core.sources.2.source.client.config.capabilities.workspace.symbol.symbolKind.valueSet.16 +number/cmp.core.sources.2.source.client.config.capabilities.workspace.symbol.symbolKind.valueSet.17 +number/cmp.core.sources.2.source.client.config.capabilities.workspace.symbol.symbolKind.valueSet.18 +number/cmp.core.sources.2.source.client.config.capabilities.workspace.symbol.symbolKind.valueSet.19 +number/cmp.core.sources.2.source.client.config.capabilities.workspace.symbol.symbolKind.valueSet.20 +number/cmp.core.sources.2.source.client.config.capabilities.workspace.symbol.symbolKind.valueSet.21 +number/cmp.core.sources.2.source.client.config.capabilities.workspace.symbol.symbolKind.valueSet.22 +number/cmp.core.sources.2.source.client.config.capabilities.workspace.symbol.symbolKind.valueSet.23 +number/cmp.core.sources.2.source.client.config.capabilities.workspace.symbol.symbolKind.valueSet.24 +number/cmp.core.sources.2.source.client.config.capabilities.workspace.symbol.symbolKind.valueSet.25 +number/cmp.core.sources.2.source.client.config.capabilities.workspace.symbol.symbolKind.valueSet.26 +boolean/cmp.core.sources.2.source.client.config.capabilities.textDocument.implementation.linkSupport +boolean/cmp.core.sources.2.source.client.config.capabilities.textDocument.references.dynamicRegistration +boolean/cmp.core.sources.2.source.client.config.capabilities.textDocument.rename.dynamicRegistration +boolean/cmp.core.sources.2.source.client.config.capabilities.textDocument.rename.prepareSupport +boolean/cmp.core.sources.2.source.client.config.capabilities.textDocument.documentHighlight.dynamicRegistration +boolean/cmp.core.sources.2.source.client.config.capabilities.textDocument.documentSymbol.dynamicRegistration +boolean/cmp.core.sources.2.source.client.config.capabilities.textDocument.documentSymbol.hierarchicalDocumentSymbolSupport +number/cmp.core.sources.2.source.client.config.capabilities.textDocument.documentSymbol.symbolKind.valueSet.1 +number/cmp.core.sources.2.source.client.config.capabilities.textDocument.documentSymbol.symbolKind.valueSet.2 +number/cmp.core.sources.2.source.client.config.capabilities.textDocument.documentSymbol.symbolKind.valueSet.3 +number/cmp.core.sources.2.source.client.config.capabilities.textDocument.documentSymbol.symbolKind.valueSet.4 +number/cmp.core.sources.2.source.client.config.capabilities.textDocument.documentSymbol.symbolKind.valueSet.5 +number/cmp.core.sources.2.source.client.config.capabilities.textDocument.documentSymbol.symbolKind.valueSet.6 +number/cmp.core.sources.2.source.client.config.capabilities.textDocument.documentSymbol.symbolKind.valueSet.7 +number/cmp.core.sources.2.source.client.config.capabilities.textDocument.documentSymbol.symbolKind.valueSet.8 +number/cmp.core.sources.2.source.client.config.capabilities.textDocument.documentSymbol.symbolKind.valueSet.9 +number/cmp.core.sources.2.source.client.config.capabilities.textDocument.documentSymbol.symbolKind.valueSet.10 +number/cmp.core.sources.2.source.client.config.capabilities.textDocument.documentSymbol.symbolKind.valueSet.11 +number/cmp.core.sources.2.source.client.config.capabilities.textDocument.documentSymbol.symbolKind.valueSet.12 +number/cmp.core.sources.2.source.client.config.capabilities.textDocument.documentSymbol.symbolKind.valueSet.13 +number/cmp.core.sources.2.source.client.config.capabilities.textDocument.documentSymbol.symbolKind.valueSet.14 +number/cmp.core.sources.2.source.client.config.capabilities.textDocument.documentSymbol.symbolKind.valueSet.15 +number/cmp.core.sources.2.source.client.config.capabilities.textDocument.documentSymbol.symbolKind.valueSet.16 +number/cmp.core.sources.2.source.client.config.capabilities.textDocument.documentSymbol.symbolKind.valueSet.17 +number/cmp.core.sources.2.source.client.config.capabilities.textDocument.documentSymbol.symbolKind.valueSet.18 +number/cmp.core.sources.2.source.client.config.capabilities.textDocument.documentSymbol.symbolKind.valueSet.19 +number/cmp.core.sources.2.source.client.config.capabilities.textDocument.documentSymbol.symbolKind.valueSet.20 +number/cmp.core.sources.2.source.client.config.capabilities.textDocument.documentSymbol.symbolKind.valueSet.21 +number/cmp.core.sources.2.source.client.config.capabilities.textDocument.documentSymbol.symbolKind.valueSet.22 +number/cmp.core.sources.2.source.client.config.capabilities.textDocument.documentSymbol.symbolKind.valueSet.23 +number/cmp.core.sources.2.source.client.config.capabilities.textDocument.documentSymbol.symbolKind.valueSet.24 +number/cmp.core.sources.2.source.client.config.capabilities.textDocument.documentSymbol.symbolKind.valueSet.25 +number/cmp.core.sources.2.source.client.config.capabilities.textDocument.documentSymbol.symbolKind.valueSet.26 +boolean/cmp.core.sources.2.source.client.config.capabilities.textDocument.synchronization.dynamicRegistration +boolean/cmp.core.sources.2.source.client.config.capabilities.textDocument.synchronization.willSave +boolean/cmp.core.sources.2.source.client.config.capabilities.textDocument.synchronization.willSaveWaitUntil +boolean/cmp.core.sources.2.source.client.config.capabilities.textDocument.synchronization.didSave +boolean/cmp.core.sources.2.source.client.config.capabilities.textDocument.codeAction.dynamicRegistration +boolean/cmp.core.sources.2.source.client.config.capabilities.textDocument.codeAction.isPreferredSupport +boolean/cmp.core.sources.2.source.client.config.capabilities.textDocument.codeAction.dataSupport +string/cmp.core.sources.2.source.client.config.capabilities.textDocument.codeAction.resolveSupport.properties.1 +string/cmp.core.sources.2.source.client.config.capabilities.textDocument.codeAction.codeActionLiteralSupport.codeActionKind.valueSet.1 +string/cmp.core.sources.2.source.client.config.capabilities.textDocument.codeAction.codeActionLiteralSupport.codeActionKind.valueSet.2 +string/cmp.core.sources.2.source.client.config.capabilities.textDocument.codeAction.codeActionLiteralSupport.codeActionKind.valueSet.3 +string/cmp.core.sources.2.source.client.config.capabilities.textDocument.codeAction.codeActionLiteralSupport.codeActionKind.valueSet.4 +string/cmp.core.sources.2.source.client.config.capabilities.textDocument.codeAction.codeActionLiteralSupport.codeActionKind.valueSet.5 +string/cmp.core.sources.2.source.client.config.capabilities.textDocument.codeAction.codeActionLiteralSupport.codeActionKind.valueSet.6 +string/cmp.core.sources.2.source.client.config.capabilities.textDocument.codeAction.codeActionLiteralSupport.codeActionKind.valueSet.7 +string/cmp.core.sources.2.source.client.config.capabilities.textDocument.codeAction.codeActionLiteralSupport.codeActionKind.valueSet.8 +string/cmp.core.sources.2.source.client.config.capabilities.textDocument.codeAction.codeActionLiteralSupport.codeActionKind.valueSet.9 +string/cmp.core.sources.2.source.client.config.capabilities.textDocument.codeAction.codeActionLiteralSupport.codeActionKind.valueSet.10 +string/cmp.core.sources.2.source.client.config.capabilities.textDocument.codeAction.codeActionLiteralSupport.codeActionKind.valueSet.11 +string/cmp.core.sources.2.source.client.config.capabilities.textDocument.codeAction.codeActionLiteralSupport.codeActionKind.valueSet.12 +string/cmp.core.sources.2.source.client.config.capabilities.textDocument.codeAction.codeActionLiteralSupport.codeActionKind.valueSet.13 +string/cmp.core.sources.2.source.client.config.capabilities.textDocument.codeAction.codeActionLiteralSupport.codeActionKind.valueSet.14 +string/cmp.core.sources.2.source.client.config.capabilities.textDocument.codeAction.codeActionLiteralSupport.codeActionKind.valueSet.15 +string/cmp.core.sources.2.source.client.config.capabilities.textDocument.codeAction.codeActionLiteralSupport.codeActionKind.valueSet.16 +boolean/cmp.core.sources.2.source.client.config.capabilities.textDocument.typeDefinition.linkSupport +number/cmp.core.sources.2.source.client.config.capabilities.textDocument.publishDiagnostics.tagSupport.valueSet.1 +number/cmp.core.sources.2.source.client.config.capabilities.textDocument.publishDiagnostics.tagSupport.valueSet.2 +boolean/cmp.core.sources.2.source.client.config.capabilities.textDocument.publishDiagnostics.relatedInformation +boolean/cmp.core.sources.2.source.client.config.capabilities.textDocument.hover.dynamicRegistration +string/cmp.core.sources.2.source.client.config.capabilities.textDocument.hover.contentFormat.1 +string/cmp.core.sources.2.source.client.config.capabilities.textDocument.hover.contentFormat.2 +boolean/cmp.core.sources.2.source.client.config.capabilities.textDocument.declaration.linkSupport +boolean/cmp.core.sources.2.source.client.config.capabilities.textDocument.completion.dynamicRegistration +boolean/cmp.core.sources.2.source.client.config.capabilities.textDocument.completion.completionItem.preselectSupport +boolean/cmp.core.sources.2.source.client.config.capabilities.textDocument.completion.completionItem.deprecatedSupport +string/cmp.core.sources.2.source.client.config.capabilities.textDocument.completion.completionItem.documentationFormat.1 +string/cmp.core.sources.2.source.client.config.capabilities.textDocument.completion.completionItem.documentationFormat.2 +boolean/cmp.core.sources.2.source.client.config.capabilities.textDocument.completion.completionItem.snippetSupport +boolean/cmp.core.sources.2.source.client.config.capabilities.textDocument.completion.completionItem.commitCharactersSupport +boolean/cmp.core.sources.2.source.client.config.capabilities.textDocument.completion.contextSupport +number/cmp.core.sources.2.source.client.config.capabilities.textDocument.completion.completionItemKind.valueSet.1 +number/cmp.core.sources.2.source.client.config.capabilities.textDocument.completion.completionItemKind.valueSet.2 +number/cmp.core.sources.2.source.client.config.capabilities.textDocument.completion.completionItemKind.valueSet.3 +number/cmp.core.sources.2.source.client.config.capabilities.textDocument.completion.completionItemKind.valueSet.4 +number/cmp.core.sources.2.source.client.config.capabilities.textDocument.completion.completionItemKind.valueSet.5 +number/cmp.core.sources.2.source.client.config.capabilities.textDocument.completion.completionItemKind.valueSet.6 +number/cmp.core.sources.2.source.client.config.capabilities.textDocument.completion.completionItemKind.valueSet.7 +number/cmp.core.sources.2.source.client.config.capabilities.textDocument.completion.completionItemKind.valueSet.8 +number/cmp.core.sources.2.source.client.config.capabilities.textDocument.completion.completionItemKind.valueSet.9 +number/cmp.core.sources.2.source.client.config.capabilities.textDocument.completion.completionItemKind.valueSet.10 +number/cmp.core.sources.2.source.client.config.capabilities.textDocument.completion.completionItemKind.valueSet.11 +number/cmp.core.sources.2.source.client.config.capabilities.textDocument.completion.completionItemKind.valueSet.12 +number/cmp.core.sources.2.source.client.config.capabilities.textDocument.completion.completionItemKind.valueSet.13 +number/cmp.core.sources.2.source.client.config.capabilities.textDocument.completion.completionItemKind.valueSet.14 +number/cmp.core.sources.2.source.client.config.capabilities.textDocument.completion.completionItemKind.valueSet.15 +number/cmp.core.sources.2.source.client.config.capabilities.textDocument.completion.completionItemKind.valueSet.16 +number/cmp.core.sources.2.source.client.config.capabilities.textDocument.completion.completionItemKind.valueSet.17 +number/cmp.core.sources.2.source.client.config.capabilities.textDocument.completion.completionItemKind.valueSet.18 +number/cmp.core.sources.2.source.client.config.capabilities.textDocument.completion.completionItemKind.valueSet.19 +number/cmp.core.sources.2.source.client.config.capabilities.textDocument.completion.completionItemKind.valueSet.20 +number/cmp.core.sources.2.source.client.config.capabilities.textDocument.completion.completionItemKind.valueSet.21 +number/cmp.core.sources.2.source.client.config.capabilities.textDocument.completion.completionItemKind.valueSet.22 +number/cmp.core.sources.2.source.client.config.capabilities.textDocument.completion.completionItemKind.valueSet.23 +number/cmp.core.sources.2.source.client.config.capabilities.textDocument.completion.completionItemKind.valueSet.24 +number/cmp.core.sources.2.source.client.config.capabilities.textDocument.completion.completionItemKind.valueSet.25 +boolean/cmp.core.sources.2.source.client.config.capabilities.textDocument.definition.linkSupport +boolean/cmp.core.sources.2.source.client.config.capabilities.textDocument.signatureHelp.dynamicRegistration +boolean/cmp.core.sources.2.source.client.config.capabilities.textDocument.signatureHelp.signatureInformation.activeParameterSupport +string/cmp.core.sources.2.source.client.config.capabilities.textDocument.signatureHelp.signatureInformation.documentationFormat.1 +string/cmp.core.sources.2.source.client.config.capabilities.textDocument.signatureHelp.signatureInformation.documentationFormat.2 +boolean/cmp.core.sources.2.source.client.config.capabilities.textDocument.signatureHelp.signatureInformation.parameterInformation.labelOffsetSupport +boolean/cmp.core.sources.2.source.client.config.capabilities.callHierarchy.dynamicRegistration +function/0/cmp.core.sources.2.source.client.config.on_attach +string/cmp.core.sources.2.source.client.config.root_dir +function/2/cmp.core.sources.2.source.client.config._on_attach +string/cmp.core.sources.2.source.client.config.name +function/2/cmp.core.sources.2.source.client.config.get_language_id +string/cmp.core.sources.2.source.client.config.workspace_folders.1.uri +string/cmp.core.sources.2.source.client.config.workspace_folders.1.name +function/0/cmp.core.sources.2.source.client.config.on_exit +boolean/cmp.core.sources.2.source.client.config.autostart +string/cmp.core.sources.2.source.client.config.cmd.1 +boolean/cmp.core.sources.2.source.client.config.single_file_support +string/cmp.core.sources.2.source.client.config.filetypes.1 +number/cmp.core.sources.2.source.client.config.log_level +number/cmp.core.sources.2.source.client.config.message_level +function/1/cmp.core.sources.2.source.client.stop +boolean/cmp.core.sources.2.source.client.attached_buffers.1 +string/cmp.core.sources.2.source.client.offset_encoding +string/cmp.core.sources.2.source.client.messages.name +function/1/cmp.core.sources.2.source.client.supports_method +function/4/cmp.core.sources.2.source.client.request +function/2/cmp.core.sources.2.source.client.notify +string/cmp.core.sources.2.source.client.name +function/4/cmp.core.sources.2.source.client.request_sync +number/cmp.core.sources.2.source.client.id +function/1/cmp.core.sources.2.source.client.workspace_did_change_configuration +boolean/cmp.core.sources.2.source.client.server_capabilities.referencesProvider +boolean/cmp.core.sources.2.source.client.server_capabilities.renameProvider.prepareProvider +boolean/cmp.core.sources.2.source.client.server_capabilities.documentLinkProvider.resolveProvider +boolean/cmp.core.sources.2.source.client.server_capabilities.documentFormattingProvider +string/cmp.core.sources.2.source.client.server_capabilities.semanticTokensProvider.legend.tokenModifiers.1 +string/cmp.core.sources.2.source.client.server_capabilities.semanticTokensProvider.legend.tokenModifiers.2 +string/cmp.core.sources.2.source.client.server_capabilities.semanticTokensProvider.legend.tokenModifiers.3 +string/cmp.core.sources.2.source.client.server_capabilities.semanticTokensProvider.legend.tokenModifiers.4 +string/cmp.core.sources.2.source.client.server_capabilities.semanticTokensProvider.legend.tokenModifiers.5 +string/cmp.core.sources.2.source.client.server_capabilities.semanticTokensProvider.legend.tokenModifiers.6 +string/cmp.core.sources.2.source.client.server_capabilities.semanticTokensProvider.legend.tokenModifiers.7 +string/cmp.core.sources.2.source.client.server_capabilities.semanticTokensProvider.legend.tokenModifiers.8 +string/cmp.core.sources.2.source.client.server_capabilities.semanticTokensProvider.legend.tokenModifiers.9 +string/cmp.core.sources.2.source.client.server_capabilities.semanticTokensProvider.legend.tokenTypes.1 +string/cmp.core.sources.2.source.client.server_capabilities.semanticTokensProvider.legend.tokenTypes.2 +string/cmp.core.sources.2.source.client.server_capabilities.semanticTokensProvider.legend.tokenTypes.3 +string/cmp.core.sources.2.source.client.server_capabilities.semanticTokensProvider.legend.tokenTypes.4 +string/cmp.core.sources.2.source.client.server_capabilities.semanticTokensProvider.legend.tokenTypes.5 +string/cmp.core.sources.2.source.client.server_capabilities.semanticTokensProvider.legend.tokenTypes.6 +string/cmp.core.sources.2.source.client.server_capabilities.semanticTokensProvider.legend.tokenTypes.7 +string/cmp.core.sources.2.source.client.server_capabilities.semanticTokensProvider.legend.tokenTypes.8 +string/cmp.core.sources.2.source.client.server_capabilities.semanticTokensProvider.legend.tokenTypes.9 +string/cmp.core.sources.2.source.client.server_capabilities.semanticTokensProvider.legend.tokenTypes.10 +string/cmp.core.sources.2.source.client.server_capabilities.semanticTokensProvider.legend.tokenTypes.11 +string/cmp.core.sources.2.source.client.server_capabilities.semanticTokensProvider.legend.tokenTypes.12 +string/cmp.core.sources.2.source.client.server_capabilities.semanticTokensProvider.legend.tokenTypes.13 +boolean/cmp.core.sources.2.source.client.server_capabilities.semanticTokensProvider.range +boolean/cmp.core.sources.2.source.client.server_capabilities.semanticTokensProvider.full.delta +string/cmp.core.sources.2.source.client.server_capabilities.completionProvider.triggerCharacters.1 +string/cmp.core.sources.2.source.client.server_capabilities.completionProvider.triggerCharacters.2 +boolean/cmp.core.sources.2.source.client.server_capabilities.documentHighlightProvider +boolean/cmp.core.sources.2.source.client.server_capabilities.hoverProvider +number/cmp.core.sources.2.source.client.server_capabilities.textDocumentSync.change +boolean/cmp.core.sources.2.source.client.server_capabilities.textDocumentSync.openClose +boolean/cmp.core.sources.2.source.client.server_capabilities.selectionRangeProvider +boolean/cmp.core.sources.2.source.client.server_capabilities.codeActionProvider +boolean/cmp.core.sources.2.source.client.server_capabilities.definitionProvider +boolean/cmp.core.sources.2.source.client.server_capabilities.documentSymbolProvider +function/1/cmp.core.sources.2.source.client._on_attach +function/1/cmp.core.sources.2.source.client.cancel_request +function/0/cmp.core.sources.2.source.client.is_stopped +boolean/cmp.core.sources.2.source.client.initialized +function/0/cmp.core.sources.2.source.client.rpc.is_closing +function/2/cmp.core.sources.2.source.client.rpc.notify +function/4/cmp.core.sources.2.source.client.rpc.request +function/0/cmp.core.sources.2.source.client.rpc.terminate +number/cmp.core.sources.2.request_offset +number/cmp.core.sources.2.status +number/cmp.core.sources.2.offset +boolean/cmp.core.sources.2.is_triggered_by_symbol +string/cmp.core.context.cursor_line +number/cmp.core.context.id +string/cmp.core.context.filetype +number/cmp.core.context.time +number/cmp.core.context.bufnr +string/cmp.core.context.cursor_after_line +string/cmp.core.context.input +string/cmp.core.context.cursor_before_line +number/cmp.core.context.cursor.row +number/cmp.core.context.cursor.col +function/1/cmp.core.view.resolve_dedup +function/1/cmp.core.view.event.events.menu_opened.1 +function/0/cmp.core.view.event.events.keymap.1 +function/1/cmp.core.view.event.events.menu_closed.1 +function/1/cmp.core.view.event.events.complete_done.1 +number/cmp.core.view.wildmenu_entries_view.entries_win.buffer_opt.tabstop +number/cmp.core.view.wildmenu_entries_view.entries_win.name +string/cmp.core.view.wildmenu_entries_view.entries_win.opt.winhighlight +boolean/cmp.core.view.wildmenu_entries_view.entries_win.opt.wrap +number/cmp.core.view.wildmenu_entries_view.entries_win.opt.conceallevel +string/cmp.core.view.wildmenu_entries_view.entries_win.opt.concealcursor +number/cmp.core.view.wildmenu_entries_view.entries_win.opt.scrolloff +number/cmp.core.view.wildmenu_entries_view.entries_win.opt.sidescrolloff +boolean/cmp.core.view.wildmenu_entries_view.entries_win.opt.foldenable +string/cmp.core.view.wildmenu_entries_view.entries_win.opt.cursorlineopt +number/cmp.core.view.wildmenu_entries_view.selected_index +number/cmp.core.view.wildmenu_entries_view.offset +boolean/cmp.core.view.wildmenu_entries_view.active +string/cmp.core.view.docs_view.window.buffer_opt.filetype +number/cmp.core.view.docs_view.window.name +number/cmp.core.view.docs_view.window.style.zindex +string/cmp.core.view.docs_view.window.style.border.1.1 +string/cmp.core.view.docs_view.window.style.border.1.2 +string/cmp.core.view.docs_view.window.style.border.2.1 +string/cmp.core.view.docs_view.window.style.border.2.2 +string/cmp.core.view.docs_view.window.style.border.3.1 +string/cmp.core.view.docs_view.window.style.border.3.2 +string/cmp.core.view.docs_view.window.style.border.4.1 +string/cmp.core.view.docs_view.window.style.border.4.2 +string/cmp.core.view.docs_view.window.style.border.5.1 +string/cmp.core.view.docs_view.window.style.border.5.2 +string/cmp.core.view.docs_view.window.style.border.6.1 +string/cmp.core.view.docs_view.window.style.border.6.2 +string/cmp.core.view.docs_view.window.style.border.7.1 +string/cmp.core.view.docs_view.window.style.border.7.2 +string/cmp.core.view.docs_view.window.style.border.8.1 +string/cmp.core.view.docs_view.window.style.border.8.2 +string/cmp.core.view.docs_view.window.style.relative +number/cmp.core.view.docs_view.window.style.row +string/cmp.core.view.docs_view.window.style.style +number/cmp.core.view.docs_view.window.style.height +number/cmp.core.view.docs_view.window.style.width +number/cmp.core.view.docs_view.window.style.col +number/cmp.core.view.docs_view.window.opt.conceallevel +boolean/cmp.core.view.docs_view.window.opt.wrap +number/cmp.core.view.docs_view.window.opt.winblend +string/cmp.core.view.docs_view.window.opt.showbreak +boolean/cmp.core.view.docs_view.window.opt.foldenable +string/cmp.core.view.docs_view.window.opt.winhighlight +number/cmp.core.view.docs_view.window.opt.scrolloff +boolean/cmp.core.view.docs_view.window.opt.linebreak +string/cmp.core.view.docs_view.window.opt.concealcursor +number/cmp.core.view.native_entries_view.preselect_index +number/cmp.core.view.native_entries_view.offset +number/cmp.core.view.custom_entries_view.offset +boolean/cmp.core.view.custom_entries_view.bottom_up +string/cmp.core.view.custom_entries_view.entries_win.buffer_opt.filetype +number/cmp.core.view.custom_entries_view.entries_win.buffer_opt.tabstop +number/cmp.core.view.custom_entries_view.entries_win.name +number/cmp.core.view.custom_entries_view.entries_win.style.zindex +string/cmp.core.view.custom_entries_view.entries_win.style.border.1.1 +string/cmp.core.view.custom_entries_view.entries_win.style.border.1.2 +string/cmp.core.view.custom_entries_view.entries_win.style.border.2.1 +string/cmp.core.view.custom_entries_view.entries_win.style.border.2.2 +string/cmp.core.view.custom_entries_view.entries_win.style.border.3.1 +string/cmp.core.view.custom_entries_view.entries_win.style.border.3.2 +string/cmp.core.view.custom_entries_view.entries_win.style.border.4.1 +string/cmp.core.view.custom_entries_view.entries_win.style.border.4.2 +string/cmp.core.view.custom_entries_view.entries_win.style.border.5.1 +string/cmp.core.view.custom_entries_view.entries_win.style.border.5.2 +string/cmp.core.view.custom_entries_view.entries_win.style.border.6.1 +string/cmp.core.view.custom_entries_view.entries_win.style.border.6.2 +string/cmp.core.view.custom_entries_view.entries_win.style.border.7.1 +string/cmp.core.view.custom_entries_view.entries_win.style.border.7.2 +string/cmp.core.view.custom_entries_view.entries_win.style.border.8.1 +string/cmp.core.view.custom_entries_view.entries_win.style.border.8.2 +string/cmp.core.view.custom_entries_view.entries_win.style.relative +number/cmp.core.view.custom_entries_view.entries_win.style.width +string/cmp.core.view.custom_entries_view.entries_win.style.style +number/cmp.core.view.custom_entries_view.entries_win.style.height +number/cmp.core.view.custom_entries_view.entries_win.style.row +number/cmp.core.view.custom_entries_view.entries_win.style.col +number/cmp.core.view.custom_entries_view.entries_win.opt.conceallevel +number/cmp.core.view.custom_entries_view.entries_win.opt.scrolloff +number/cmp.core.view.custom_entries_view.entries_win.opt.winblend +boolean/cmp.core.view.custom_entries_view.entries_win.opt.cursorline +boolean/cmp.core.view.custom_entries_view.entries_win.opt.foldenable +string/cmp.core.view.custom_entries_view.entries_win.opt.cursorlineopt +string/cmp.core.view.custom_entries_view.entries_win.opt.winhighlight +boolean/cmp.core.view.custom_entries_view.entries_win.opt.wrap +string/cmp.core.view.custom_entries_view.entries_win.opt.concealcursor +number/cmp.core.view.custom_entries_view.column_width.menu +number/cmp.core.view.custom_entries_view.column_width.kind +number/cmp.core.view.custom_entries_view.column_width.abbr +function/0/cmp.core.view.custom_entries_view.event.events.change.1 +boolean/cmp.core.view.custom_entries_view.active +function/1/cmp.core.event.events.confirm_done.1 +function/1/cmp.core.event.events.confirm_done.2 +function/1/cmp.core.event.events.complete_done.1 +function/0/cmp.complete_common_string +function/0/cmp.status +function/0/cmp.get_active_entry +function/0/cmp.get_entries +function/0/cmp.close +function/0/cmp.confirm +function/0/cmp.scroll_docs +function/0/cmp.select_prev_item +function/0/cmp.select_next_item +function/0/cmp.get_config +function/0/cmp.abort +function/0/cmp.get_selected_entry +function/0/cmp.visible +function/2/cmp.config.compare.score +function/2/cmp.config.compare.exact +function/2/cmp.config.compare.recently_used.add_entry +function/2/cmp.config.compare.offset +function/2/cmp.config.compare.sort_text +function/1/cmp.config.compare.scopes.update +function/2/cmp.config.compare.length +function/2/cmp.config.compare.order +number/cmp.config.compare.locality.lines_cache.entries.buf +function/1/cmp.config.compare.locality.update +number/cmp.config.compare.locality.lines_count +function/2/cmp.config.compare.kind +userdata/cmp.config.disable +function/1/cmp.config.window.bordered +function/0/cmp.config.sources +function/1/cmp.sync +function/3/luasnip.util.mark.mark +function/1/nvim-tree.actions.moves.parent.fn +function/1/luasnip.util.pattern_tokenizer.tokenize +function/3/luasnip.util.str.unescaped_pairs +function/1/luasnip.util.str.vscode_string_modifiers.capitalize +function/1/luasnip.util.str.vscode_string_modifiers.camelcase +function/1/luasnip.util.str.vscode_string_modifiers.pascalcase +function/0/luasnip.util.str.vscode_string_modifiers.upcase +function/0/luasnip.util.str.vscode_string_modifiers.downcase +function/1/luasnip.util.str.aupatescape +function/2/luasnip.util.str.process_multiline +function/1/luasnip.util.str.sanitize +function/1/luasnip.util.str.dedent +function/1/luasnip.util.dict.new +function/1/nvim-tree.actions.apply_mappings +function/0/nvim-tree.actions.default_mappings_clone +function/0/nvim-tree.actions.active_mappings_clone +string/nvim-tree.actions.mappings.1.desc +string/nvim-tree.actions.mappings.1.key.1 +string/nvim-tree.actions.mappings.1.key.2 +string/nvim-tree.actions.mappings.1.key.3 +string/nvim-tree.actions.mappings.1.action +string/nvim-tree.actions.mappings.2.desc +string/nvim-tree.actions.mappings.2.key +string/nvim-tree.actions.mappings.2.action +string/nvim-tree.actions.mappings.3.desc +string/nvim-tree.actions.mappings.3.key +string/nvim-tree.actions.mappings.3.action +string/nvim-tree.actions.mappings.4.desc +string/nvim-tree.actions.mappings.4.key.1 +string/nvim-tree.actions.mappings.4.key.2 +string/nvim-tree.actions.mappings.4.action +string/nvim-tree.actions.mappings.5.desc +string/nvim-tree.actions.mappings.5.key +string/nvim-tree.actions.mappings.5.action +string/nvim-tree.actions.mappings.6.desc +string/nvim-tree.actions.mappings.6.key +string/nvim-tree.actions.mappings.6.action +string/nvim-tree.actions.mappings.7.desc +string/nvim-tree.actions.mappings.7.key +string/nvim-tree.actions.mappings.7.action +string/nvim-tree.actions.mappings.8.desc +string/nvim-tree.actions.mappings.8.key +string/nvim-tree.actions.mappings.8.action +string/nvim-tree.actions.mappings.9.desc +string/nvim-tree.actions.mappings.9.key +string/nvim-tree.actions.mappings.9.action +string/nvim-tree.actions.mappings.10.desc +string/nvim-tree.actions.mappings.10.key +string/nvim-tree.actions.mappings.10.action +string/nvim-tree.actions.mappings.11.desc +string/nvim-tree.actions.mappings.11.key +string/nvim-tree.actions.mappings.11.action +string/nvim-tree.actions.mappings.12.desc +string/nvim-tree.actions.mappings.12.key +string/nvim-tree.actions.mappings.12.action +string/nvim-tree.actions.mappings.13.desc +string/nvim-tree.actions.mappings.13.key +string/nvim-tree.actions.mappings.13.action +string/nvim-tree.actions.mappings.14.desc +string/nvim-tree.actions.mappings.14.key +string/nvim-tree.actions.mappings.14.action +string/nvim-tree.actions.mappings.15.desc +string/nvim-tree.actions.mappings.15.key +string/nvim-tree.actions.mappings.15.action +string/nvim-tree.actions.mappings.16.desc +string/nvim-tree.actions.mappings.16.key +string/nvim-tree.actions.mappings.16.action +string/nvim-tree.actions.mappings.17.desc +string/nvim-tree.actions.mappings.17.key +string/nvim-tree.actions.mappings.17.action +string/nvim-tree.actions.mappings.18.desc +string/nvim-tree.actions.mappings.18.key +string/nvim-tree.actions.mappings.18.action +string/nvim-tree.actions.mappings.19.desc +string/nvim-tree.actions.mappings.19.key +string/nvim-tree.actions.mappings.19.action +string/nvim-tree.actions.mappings.20.desc +string/nvim-tree.actions.mappings.20.key +string/nvim-tree.actions.mappings.20.action +string/nvim-tree.actions.mappings.21.desc +string/nvim-tree.actions.mappings.21.key +string/nvim-tree.actions.mappings.21.action +string/nvim-tree.actions.mappings.22.desc +string/nvim-tree.actions.mappings.22.key +string/nvim-tree.actions.mappings.22.action +string/nvim-tree.actions.mappings.23.desc +string/nvim-tree.actions.mappings.23.key +string/nvim-tree.actions.mappings.23.action +string/nvim-tree.actions.mappings.24.desc +string/nvim-tree.actions.mappings.24.key +string/nvim-tree.actions.mappings.24.action +string/nvim-tree.actions.mappings.25.desc +string/nvim-tree.actions.mappings.25.key +string/nvim-tree.actions.mappings.25.action +string/nvim-tree.actions.mappings.26.desc +string/nvim-tree.actions.mappings.26.key +string/nvim-tree.actions.mappings.26.action +string/nvim-tree.actions.mappings.27.desc +string/nvim-tree.actions.mappings.27.key +string/nvim-tree.actions.mappings.27.action +string/nvim-tree.actions.mappings.28.desc +string/nvim-tree.actions.mappings.28.key +string/nvim-tree.actions.mappings.28.action +string/nvim-tree.actions.mappings.29.desc +string/nvim-tree.actions.mappings.29.key +string/nvim-tree.actions.mappings.29.action +string/nvim-tree.actions.mappings.30.desc +string/nvim-tree.actions.mappings.30.key +string/nvim-tree.actions.mappings.30.action +string/nvim-tree.actions.mappings.31.desc +string/nvim-tree.actions.mappings.31.key +string/nvim-tree.actions.mappings.31.action +string/nvim-tree.actions.mappings.32.desc +string/nvim-tree.actions.mappings.32.key +string/nvim-tree.actions.mappings.32.action +string/nvim-tree.actions.mappings.33.desc +string/nvim-tree.actions.mappings.33.key +string/nvim-tree.actions.mappings.33.action +string/nvim-tree.actions.mappings.34.desc +string/nvim-tree.actions.mappings.34.key +string/nvim-tree.actions.mappings.34.action +string/nvim-tree.actions.mappings.35.desc +string/nvim-tree.actions.mappings.35.key +string/nvim-tree.actions.mappings.35.action +string/nvim-tree.actions.mappings.36.desc +string/nvim-tree.actions.mappings.36.key +string/nvim-tree.actions.mappings.36.action +string/nvim-tree.actions.mappings.37.desc +string/nvim-tree.actions.mappings.37.key +string/nvim-tree.actions.mappings.37.action +string/nvim-tree.actions.mappings.38.desc +string/nvim-tree.actions.mappings.38.key +string/nvim-tree.actions.mappings.38.action +string/nvim-tree.actions.mappings.39.desc +string/nvim-tree.actions.mappings.39.key +string/nvim-tree.actions.mappings.39.action +string/nvim-tree.actions.mappings.40.desc +string/nvim-tree.actions.mappings.40.key +string/nvim-tree.actions.mappings.40.action +string/nvim-tree.actions.mappings.41.desc +string/nvim-tree.actions.mappings.41.key +string/nvim-tree.actions.mappings.41.action +string/nvim-tree.actions.mappings.42.desc +string/nvim-tree.actions.mappings.42.key +string/nvim-tree.actions.mappings.42.action +string/nvim-tree.actions.mappings.43.desc +string/nvim-tree.actions.mappings.43.key +string/nvim-tree.actions.mappings.43.action +string/nvim-tree.actions.mappings.44.desc +string/nvim-tree.actions.mappings.44.key +string/nvim-tree.actions.mappings.44.action +string/nvim-tree.actions.mappings.45.desc +string/nvim-tree.actions.mappings.45.key +string/nvim-tree.actions.mappings.45.action +string/nvim-tree.actions.mappings.46.desc +string/nvim-tree.actions.mappings.46.key +string/nvim-tree.actions.mappings.46.action +string/nvim-tree.actions.mappings.47.desc +string/nvim-tree.actions.mappings.47.key +string/nvim-tree.actions.mappings.47.action +string/nvim-tree.actions.mappings.48.desc +string/nvim-tree.actions.mappings.48.key +string/nvim-tree.actions.mappings.48.action +string/nvim-tree.actions.mappings.49.desc +string/nvim-tree.actions.mappings.49.key +string/nvim-tree.actions.mappings.49.action +function/1/nvim-tree.actions.setup +function/1/nvim-tree.keymap.set_keymaps +function/1/nvim-tree.keymap.keymaps.1.callback +string/nvim-tree.keymap.keymaps.1.desc +string/nvim-tree.keymap.keymaps.1.key.1 +string/nvim-tree.keymap.keymaps.1.key.2 +string/nvim-tree.keymap.keymaps.1.key.3 +function/1/nvim-tree.keymap.keymaps.2.callback +string/nvim-tree.keymap.keymaps.2.desc +string/nvim-tree.keymap.keymaps.2.key +function/1/nvim-tree.keymap.keymaps.3.callback +string/nvim-tree.keymap.keymaps.3.desc +string/nvim-tree.keymap.keymaps.3.key +function/1/nvim-tree.keymap.keymaps.4.callback +string/nvim-tree.keymap.keymaps.4.desc +string/nvim-tree.keymap.keymaps.4.key.1 +string/nvim-tree.keymap.keymaps.4.key.2 +function/1/nvim-tree.keymap.keymaps.5.callback +string/nvim-tree.keymap.keymaps.5.desc +string/nvim-tree.keymap.keymaps.5.key +function/1/nvim-tree.keymap.keymaps.6.callback +string/nvim-tree.keymap.keymaps.6.desc +string/nvim-tree.keymap.keymaps.6.key +function/1/nvim-tree.keymap.keymaps.7.callback +string/nvim-tree.keymap.keymaps.7.desc +string/nvim-tree.keymap.keymaps.7.key +function/1/nvim-tree.keymap.keymaps.8.callback +string/nvim-tree.keymap.keymaps.8.desc +string/nvim-tree.keymap.keymaps.8.key +function/1/nvim-tree.keymap.keymaps.9.callback +string/nvim-tree.keymap.keymaps.9.desc +string/nvim-tree.keymap.keymaps.9.key +function/1/nvim-tree.keymap.keymaps.10.callback +string/nvim-tree.keymap.keymaps.10.desc +string/nvim-tree.keymap.keymaps.10.key +function/1/nvim-tree.keymap.keymaps.11.callback +string/nvim-tree.keymap.keymaps.11.desc +string/nvim-tree.keymap.keymaps.11.key +function/1/nvim-tree.keymap.keymaps.12.callback +string/nvim-tree.keymap.keymaps.12.desc +string/nvim-tree.keymap.keymaps.12.key +function/1/nvim-tree.keymap.keymaps.13.callback +string/nvim-tree.keymap.keymaps.13.desc +string/nvim-tree.keymap.keymaps.13.key +function/1/nvim-tree.keymap.keymaps.14.callback +string/nvim-tree.keymap.keymaps.14.desc +string/nvim-tree.keymap.keymaps.14.key +function/0/nvim-tree.keymap.keymaps.15.callback +string/nvim-tree.keymap.keymaps.15.desc +string/nvim-tree.keymap.keymaps.15.key +function/0/nvim-tree.keymap.keymaps.16.callback +string/nvim-tree.keymap.keymaps.16.desc +string/nvim-tree.keymap.keymaps.16.key +function/0/nvim-tree.keymap.keymaps.17.callback +string/nvim-tree.keymap.keymaps.17.desc +string/nvim-tree.keymap.keymaps.17.key +function/2/nvim-tree.keymap.keymaps.18.callback +string/nvim-tree.keymap.keymaps.18.desc +string/nvim-tree.keymap.keymaps.18.key +function/1/nvim-tree.keymap.keymaps.19.callback +string/nvim-tree.keymap.keymaps.19.desc +string/nvim-tree.keymap.keymaps.19.key +function/1/nvim-tree.keymap.keymaps.20.callback +string/nvim-tree.keymap.keymaps.20.desc +string/nvim-tree.keymap.keymaps.20.key +function/1/nvim-tree.keymap.keymaps.21.callback +string/nvim-tree.keymap.keymaps.21.desc +string/nvim-tree.keymap.keymaps.21.key +function/1/nvim-tree.keymap.keymaps.22.callback +string/nvim-tree.keymap.keymaps.22.desc +string/nvim-tree.keymap.keymaps.22.key +function/1/nvim-tree.keymap.keymaps.23.callback +string/nvim-tree.keymap.keymaps.23.desc +string/nvim-tree.keymap.keymaps.23.key +function/1/nvim-tree.keymap.keymaps.24.callback +string/nvim-tree.keymap.keymaps.24.desc +string/nvim-tree.keymap.keymaps.24.key +function/1/nvim-tree.keymap.keymaps.25.callback +string/nvim-tree.keymap.keymaps.25.desc +string/nvim-tree.keymap.keymaps.25.key +function/1/nvim-tree.keymap.keymaps.26.callback +string/nvim-tree.keymap.keymaps.26.desc +string/nvim-tree.keymap.keymaps.26.key +function/1/nvim-tree.keymap.keymaps.27.callback +string/nvim-tree.keymap.keymaps.27.desc +string/nvim-tree.keymap.keymaps.27.key +function/1/nvim-tree.keymap.keymaps.28.callback +string/nvim-tree.keymap.keymaps.28.desc +string/nvim-tree.keymap.keymaps.28.key +function/1/nvim-tree.keymap.keymaps.29.callback +string/nvim-tree.keymap.keymaps.29.desc +string/nvim-tree.keymap.keymaps.29.key +function/1/nvim-tree.keymap.keymaps.30.callback +string/nvim-tree.keymap.keymaps.30.desc +string/nvim-tree.keymap.keymaps.30.key +function/1/nvim-tree.keymap.keymaps.31.callback +string/nvim-tree.keymap.keymaps.31.desc +string/nvim-tree.keymap.keymaps.31.key +function/1/nvim-tree.keymap.keymaps.32.callback +string/nvim-tree.keymap.keymaps.32.desc +string/nvim-tree.keymap.keymaps.32.key +function/1/nvim-tree.keymap.keymaps.33.callback +string/nvim-tree.keymap.keymaps.33.desc +string/nvim-tree.keymap.keymaps.33.key +function/1/nvim-tree.keymap.keymaps.34.callback +string/nvim-tree.keymap.keymaps.34.desc +string/nvim-tree.keymap.keymaps.34.key +function/1/nvim-tree.keymap.keymaps.35.callback +string/nvim-tree.keymap.keymaps.35.desc +string/nvim-tree.keymap.keymaps.35.key +function/0/nvim-tree.keymap.keymaps.36.callback +string/nvim-tree.keymap.keymaps.36.desc +string/nvim-tree.keymap.keymaps.36.key +function/0/nvim-tree.keymap.keymaps.37.callback +string/nvim-tree.keymap.keymaps.37.desc +string/nvim-tree.keymap.keymaps.37.key +function/0/nvim-tree.keymap.keymaps.38.callback +string/nvim-tree.keymap.keymaps.38.desc +string/nvim-tree.keymap.keymaps.38.key +function/1/nvim-tree.keymap.keymaps.39.callback +string/nvim-tree.keymap.keymaps.39.desc +string/nvim-tree.keymap.keymaps.39.key +function/1/nvim-tree.keymap.keymaps.40.callback +string/nvim-tree.keymap.keymaps.40.desc +string/nvim-tree.keymap.keymaps.40.key +function/0/nvim-tree.keymap.keymaps.41.callback +string/nvim-tree.keymap.keymaps.41.desc +string/nvim-tree.keymap.keymaps.41.key +function/1/nvim-tree.keymap.keymaps.42.callback +string/nvim-tree.keymap.keymaps.42.desc +string/nvim-tree.keymap.keymaps.42.key +function/1/nvim-tree.keymap.keymaps.43.callback +string/nvim-tree.keymap.keymaps.43.desc +string/nvim-tree.keymap.keymaps.43.key +function/0/nvim-tree.keymap.keymaps.44.callback +string/nvim-tree.keymap.keymaps.44.desc +string/nvim-tree.keymap.keymaps.44.key +function/1/nvim-tree.keymap.keymaps.45.callback +string/nvim-tree.keymap.keymaps.45.desc +string/nvim-tree.keymap.keymaps.45.key +function/0/nvim-tree.keymap.keymaps.46.callback +string/nvim-tree.keymap.keymaps.46.desc +string/nvim-tree.keymap.keymaps.46.key +function/1/nvim-tree.keymap.setup +function/2/nvim-tree.explorer.explore +function/3/nvim-tree.explorer.reload +function/1/nvim-tree.explorer.setup +function/1/nvim-tree.explorer.Explorer.destroy +function/1/nvim-tree.explorer.Explorer.new +function/2/nvim-tree.explorer.Explorer._load +function/2/nvim-tree.explorer.Explorer.expand +function/1/nvim-tree.live-filter.apply_filter +function/1/nvim-tree.live-filter.setup +boolean/nvim-tree.live-filter.always_show_folders +string/nvim-tree.live-filter.prefix +function/0/nvim-tree.live-filter.start_filtering +function/0/nvim-tree.live-filter.clear_filter +function/1/nvim-tree.marks.toggle_mark +function/1/nvim-tree.marks.get_mark +function/0/nvim-tree.marks.clear_marks +function/0/nvim-tree.marks.get_marks +function/1/nvim-tree.marks.setup +function/0/nvim-tree.marks.draw +function/0/nvim-tree.marks.clear +function/1/nvim-tree.watcher.Watcher.destroy +function/5/nvim-tree.watcher.Watcher.new +function/1/nvim-tree.watcher.Watcher.start +function/0/nvim-tree.watcher.purge_watchers +function/1/nvim-tree.watcher.is_fs_event_capable +function/1/luasnip.util.parser.ast_utils.parse_order +function/1/luasnip.util.parser.ast_utils.apply_transform +function/1/luasnip.util.parser.ast_utils.add_dependents +function/1/luasnip.util.parser.ast_utils.fix_zero +function/1/luasnip.util.parser.ast_utils.give_vars_previous_text +function/1/luasnip.util.parser.ast_utils.give_vars_potential_tabstop +function/2/luasnip.util.parser.ast_parser.to_luasnip_nodes +function/1/nvim-autopairs._log.error +function/1/nvim-autopairs._log.info +function/1/nvim-autopairs._log.debug +function/3/nvim-autopairs.utils.compare +function/2/nvim-autopairs.utils.text_get_line +function/2/nvim-autopairs.utils.repeat_key +function/3/nvim-autopairs.utils.text_sub_char +function/1/nvim-autopairs.utils.insert_char +function/1/nvim-autopairs.utils.get_prev_char +function/1/nvim-autopairs.utils.is_bracket +function/1/nvim-autopairs.utils.is_quote +function/3/nvim-autopairs.utils.is_in_quotes +function/1/nvim-autopairs.utils.set_vchar +function/2/nvim-autopairs.utils.feed +function/1/nvim-autopairs.utils.esc +function/1/nvim-autopairs.utils.text_get_current_line +function/2/nvim-autopairs.utils.set_attach +function/1/nvim-autopairs.utils.get_cursor +function/0/nvim-autopairs.utils.is_block_wise_mode +function/1/nvim-autopairs.utils.is_close_bracket +function/2/nvim-autopairs.utils.check_filetype +function/2/nvim-autopairs.utils.check_not_filetype +function/5/nvim-autopairs.utils.text_cusor_line +function/2/nvim-autopairs.utils.is_in_table +string/nvim-autopairs.utils.key.right +string/nvim-autopairs.utils.key.join_right +string/nvim-autopairs.utils.key.bs +string/nvim-autopairs.utils.key.left +string/nvim-autopairs.utils.key.abbr +string/nvim-autopairs.utils.key.noundo_sequence +string/nvim-autopairs.utils.key.undo_sequence +string/nvim-autopairs.utils.key.c_h +string/nvim-autopairs.utils.key.del +string/nvim-autopairs.utils.key.join_left +function/3/nvim-autopairs.utils.is_in_range +function/1/nvim-autopairs.utils.is_attached +function/2/luasnip.nodes.textNode.T +boolean/luasnip.nodes.textNode.textNode.static_visible +boolean/luasnip.nodes.textNode.textNode.merge_node_ext_opts +function/1/luasnip.nodes.textNode.textNode.update_all_dependents +boolean/luasnip.nodes.textNode.textNode.visited +boolean/luasnip.nodes.textNode.textNode.visible +function/1/luasnip.nodes.textNode.textNode.is_interactive +number/luasnip.nodes.textNode.textNode.node_ext_opts.base_prio +function/3/luasnip.nodes.textNode.textNode.input_enter +function/1/nvim-autopairs.rules.basic.quote_creator +function/1/nvim-autopairs.rules.basic.setup +function/1/nvim-autopairs.rules.basic.bracket_creator +number/luasnip.util.events.change_choice +number/luasnip.util.events.pre_expand +number/luasnip.util.events.enter +number/luasnip.util.events.leave +function/2/luasnip.util.events.to_string +function/1/luasnip.nodes.util.wrap_args +function/2/luasnip.nodes.util.get_nodes_between +function/3/luasnip.nodes.util.leave_nodes_between +function/3/luasnip.nodes.util.enter_nodes_between +function/1/luasnip.nodes.util.select_node +function/3/luasnip.nodes.util.init_child_positions_func +function/1/luasnip.nodes.util.print_dict +function/1/luasnip.nodes.util.init_node_opts +function/2/luasnip.nodes.util.snippet_extend_context +function/3/luasnip.nodes.util.make_args_absolute +function/2/luasnip.nodes.util.subsnip_init_children +function/1/luasnip.nodes.node.Node.get_docstring +function/1/luasnip.nodes.node.Node.update_dependents +function/1/luasnip.nodes.node.Node.is_interactive +function/1/luasnip.nodes.node.Node._update_dependents +function/1/luasnip.nodes.node.Node.exit +function/2/luasnip.nodes.node.Node.jumpable +function/1/luasnip.nodes.node.Node.update_static +function/1/luasnip.nodes.node.Node.get_static_text +function/1/luasnip.nodes.node.Node.get_text +function/1/luasnip.nodes.node.Node.set_old_text +function/1/luasnip.nodes.node.Node.update_restore +function/1/luasnip.nodes.node.Node.store +function/2/luasnip.nodes.node.Node.indent +function/1/luasnip.nodes.node.Node.get_args +function/4/luasnip.nodes.node.Node.jump_from +function/2/luasnip.nodes.node.Node.set_ext_opts +function/3/luasnip.nodes.node.Node.expand_tabs +function/1/luasnip.nodes.node.Node.get_static_args +function/1/luasnip.nodes.node.Node.get_jump_index +function/2/luasnip.nodes.node.Node.init_dry_run_active +function/2/luasnip.nodes.node.Node.get_buf_position +function/2/luasnip.nodes.node.Node.is_active +function/1/luasnip.nodes.node.Node.static_init +function/3/luasnip.nodes.node.Node.resolve_node_ext_opts +function/4/luasnip.nodes.node.Node.jump_into +function/2/luasnip.nodes.node.Node.init_positions +function/2/luasnip.nodes.node.Node.init_insert_positions +function/1/luasnip.nodes.node.Node.make_args_absolute +function/1/luasnip.nodes.node.Node.set_dependents +function/2/luasnip.nodes.node.Node.event +function/1/luasnip.nodes.node.Node.subsnip_init +function/2/luasnip.nodes.node.Node.set_argnodes +function/2/luasnip.nodes.node.Node.put_initial +function/3/luasnip.nodes.node.Node.input_enter +function/1/luasnip.nodes.node.Node.update +function/1/luasnip.nodes.node.Node.get_passive_ext_opts +function/1/luasnip.nodes.node.Node.update_all_dependents +function/3/luasnip.nodes.node.Node.new +function/1/luasnip.nodes.node.Node.find_node +function/3/luasnip.nodes.node.Node.input_leave +function/3/luasnip.nodes.node.Node.set_mark_rgrav +boolean/luasnip.nodes.node.Node.ext_gravities_active.1 +boolean/luasnip.nodes.node.Node.ext_gravities_active.2 +function/2/luasnip.nodes.node.Node.insert_to_node_absolute +function/1/luasnip.nodes.node.Node.update_dependents_static +function/1/luasnip.nodes.node.Node.update_all_dependents_static +function/1/luasnip.nodes.node.Node._update_dependents_static +function/2/luasnip.nodes.node.Node.resolve_position +function/3/luasnip.util.parser.parse_snipmate +function/3/luasnip.util.parser.parse_snippet +function/3/package.loaded.luasnip.nodes.snippetProxy +function/1/nvim-tree.actions.dispatch.dispatch +function/1/nvim-tree.actions.dispatch.setup +function/1/luasnip.loaders.from_snipmate._load_lazy_loaded_ft +function/1/luasnip.loaders.from_snipmate._load_lazy_loaded +function/1/luasnip.loaders.from_snipmate.load +function/1/luasnip.loaders.from_snipmate.lazy_load +function/1/luasnip.loaders.from_snipmate._reload_file +function/0/luasnip.loaders.from_snipmate.edit_snippet_files +function/0/mpack.Session +function/0/mpack.decode +function/0/mpack.encode +userdata/mpack.NIL +function/0/mpack.Unpacker +function/0/mpack.Packer +function/1/cmp.config.cache.entries.get:default:2::1:35:1.mapping..i +function/1/cmp.config.cache.entries.get:default:2::1:35:1.mapping..i +function/1/cmp.config.cache.entries.get:default:2::1:35:1.mapping..s +function/1/cmp.config.cache.entries.get:default:2::1:35:1.mapping..i +function/1/cmp.config.cache.entries.get:default:2::1:35:1.mapping..i +function/1/cmp.config.cache.entries.get:default:2::1:35:1.mapping..i +function/1/cmp.config.cache.entries.get:default:2::1:35:1.mapping..s +function/1/cmp.config.cache.entries.get:default:2::1:35:1.mapping..i +function/1/cmp.config.cache.entries.get:default:2::1:35:1.mapping..i +string/cmp.config.cache.entries.get:default:2::1:35:1.preselect +boolean/cmp.config.cache.entries.get:default:2::1:35:1.matching.disallow_partial_matching +boolean/cmp.config.cache.entries.get:default:2::1:35:1.matching.disallow_partial_fuzzy_matching +boolean/cmp.config.cache.entries.get:default:2::1:35:1.matching.disallow_fuzzy_matching +boolean/cmp.config.cache.entries.get:default:2::1:35:1.matching.disallow_prefix_unmatching +boolean/cmp.config.cache.entries.get:default:2::1:35:1.experimental.ghost_text +string/cmp.config.cache.entries.get:default:2::1:35:1.confirmation.default_behavior +function/1/cmp.config.cache.entries.get:default:2::1:35:1.confirmation.get_commit_characters +string/cmp.config.cache.entries.get:default:2::1:35:1.window.completion.winhighlight +number/cmp.config.cache.entries.get:default:2::1:35:1.window.completion.scrolloff +number/cmp.config.cache.entries.get:default:2::1:35:1.window.completion.col_offset +number/cmp.config.cache.entries.get:default:2::1:35:1.window.completion.side_padding +boolean/cmp.config.cache.entries.get:default:2::1:35:1.window.completion.scrollbar +string/cmp.config.cache.entries.get:default:2::1:35:1.window.documentation.winhighlight +number/cmp.config.cache.entries.get:default:2::1:35:1.window.documentation.max_width +number/cmp.config.cache.entries.get:default:2::1:35:1.window.documentation.max_height +function/1/cmp.config.cache.entries.get:default:2::1:35:1.snippet.expand +number/cmp.config.cache.entries.get:default:2::1:35:1.performance.throttle +number/cmp.config.cache.entries.get:default:2::1:35:1.performance.debounce +number/cmp.config.cache.entries.get:default:2::1:35:1.performance.fetching_timeout +number/cmp.config.cache.entries.get:default:2::1:35:1.revision +number/cmp.config.cache.entries.get:default:2::1:35:1.sorting.priority_weight +function/2/cmp.config.cache.entries.get:default:2::1:35:1.sorting.comparators.1 +function/2/cmp.config.cache.entries.get:default:2::1:35:1.sorting.comparators.2 +function/2/cmp.config.cache.entries.get:default:2::1:35:1.sorting.comparators.3 +function/2/cmp.config.cache.entries.get:default:2::1:35:1.sorting.comparators.6 +function/2/cmp.config.cache.entries.get:default:2::1:35:1.sorting.comparators.7 +function/2/cmp.config.cache.entries.get:default:2::1:35:1.sorting.comparators.8 +string/cmp.config.cache.entries.get:default:2::1:35:1.formatting.fields.1 +string/cmp.config.cache.entries.get:default:2::1:35:1.formatting.fields.2 +string/cmp.config.cache.entries.get:default:2::1:35:1.formatting.fields.3 +function/2/cmp.config.cache.entries.get:default:2::1:35:1.formatting.format +boolean/cmp.config.cache.entries.get:default:2::1:35:1.formatting.expandable_indicator +function/0/cmp.config.cache.entries.get:default:2::1:35:1.enabled +string/cmp.config.cache.entries.get:default:2::1:35:1.view.entries.name +string/cmp.config.cache.entries.get:default:2::1:35:1.view.entries.selection_order +string/cmp.config.cache.entries.get:default:2::1:35:1.completion.completeopt +number/cmp.config.cache.entries.get:default:2::1:35:1.completion.keyword_length +string/cmp.config.cache.entries.get:default:2::1:35:1.completion.autocomplete.1 +string/cmp.config.cache.entries.get:default:2::1:35:1.completion.keyword_pattern +number/cmp.config.cache.entries.get:default:2::1:35:1.sources.1.group_index +string/cmp.config.cache.entries.get:default:2::1:35:1.sources.1.name +number/cmp.config.cache.entries.get:default:2::1:35:1.sources.2.group_index +string/cmp.config.cache.entries.get:default:2::1:35:1.sources.2.name +string/cmp.config.cache.entries.get:cmdline:2:/:1.preselect +number/cmp.config.cache.entries.get:cmdline:2:/:1.revision +function/0/cmp.config.cache.entries.get:cmdline:2:/:1.enabled +string/cmp.config.cache.entries.get:default:2:vim:1:24:1.preselect +number/cmp.config.cache.entries.get:default:2:vim:1:24:1.revision +function/0/cmp.config.cache.entries.get:default:2:vim:1:24:1.enabled +string/cmp.config.cache.entries.get:cmdline:2::1.preselect +number/cmp.config.cache.entries.get:cmdline:2::1.revision +function/0/cmp.config.cache.entries.get:cmdline:2::1.enabled +string/cmp.config.cache.entries.get:default:2::1:22:1.preselect +number/cmp.config.cache.entries.get:default:2::1:22:1.revision +function/0/cmp.config.cache.entries.get:default:2::1:22:1.enabled +function/0/cmp.config.cache.entries.get:default:0::1:1:1.enabled +function/2/cmp.config.cache.entries.get:default:0::1:1:1.formatting.format +boolean/cmp.config.cache.entries.get:default:0::1:1:1.formatting.expandable_indicator +string/cmp.config.cache.entries.get:default:0::1:1:1.window.documentation.winhighlight +string/cmp.config.cache.entries.get:default:0::1:1:1.window.documentation.border.1 +string/cmp.config.cache.entries.get:default:0::1:1:1.window.documentation.border.2 +string/cmp.config.cache.entries.get:default:0::1:1:1.window.documentation.border.3 +string/cmp.config.cache.entries.get:default:0::1:1:1.window.documentation.border.4 +string/cmp.config.cache.entries.get:default:0::1:1:1.window.documentation.border.5 +string/cmp.config.cache.entries.get:default:0::1:1:1.window.documentation.border.6 +string/cmp.config.cache.entries.get:default:0::1:1:1.window.documentation.border.7 +string/cmp.config.cache.entries.get:default:0::1:1:1.window.documentation.border.8 +number/cmp.config.cache.entries.get:default:0::1:1:1.window.documentation.max_width +number/cmp.config.cache.entries.get:default:0::1:1:1.window.documentation.max_height +string/cmp.config.cache.entries.get:default:0::1:1:1.window.completion.winhighlight +number/cmp.config.cache.entries.get:default:0::1:1:1.window.completion.scrolloff +number/cmp.config.cache.entries.get:default:0::1:1:1.window.completion.col_offset +number/cmp.config.cache.entries.get:default:0::1:1:1.window.completion.side_padding +string/cmp.config.cache.entries.get:default:0::1:1:1.window.completion.border.1 +string/cmp.config.cache.entries.get:default:0::1:1:1.window.completion.border.2 +string/cmp.config.cache.entries.get:default:0::1:1:1.window.completion.border.3 +string/cmp.config.cache.entries.get:default:0::1:1:1.window.completion.border.4 +string/cmp.config.cache.entries.get:default:0::1:1:1.window.completion.border.5 +string/cmp.config.cache.entries.get:default:0::1:1:1.window.completion.border.6 +string/cmp.config.cache.entries.get:default:0::1:1:1.window.completion.border.7 +string/cmp.config.cache.entries.get:default:0::1:1:1.window.completion.border.8 +boolean/cmp.config.cache.entries.get:default:0::1:1:1.window.completion.scrollbar +function/1/cmp.config.cache.entries.get:default:0::1:1:1.snippet.expand +number/cmp.config.cache.entries.get:default:0::1:1:1.revision +string/cmp.config.cache.entries.get:default:0::1:1:1.preselect +string/cmp.config.cache.entries.get:default:2::1:51:1.preselect +number/cmp.config.cache.entries.get:default:2::1:51:1.revision +function/0/cmp.config.cache.entries.get:default:2::1:51:1.enabled +string/cmp.config.cache.entries.get:cmdline:2:::1.preselect +number/cmp.config.cache.entries.get:cmdline:2:::1.revision +function/0/cmp.config.cache.entries.get:cmdline:2:::1.enabled +string/cmp.config.cache.entries.get:default:2:nix:1:1:1.preselect +number/cmp.config.cache.entries.get:default:2:nix:1:1:1.revision +function/0/cmp.config.cache.entries.get:default:2:nix:1:1:1.enabled +string/cmp.config.cache.entries.get:default:2:lua:1:22:1.preselect +number/cmp.config.cache.entries.get:default:2:lua:1:22:1.revision +function/0/cmp.config.cache.entries.get:default:2:lua:1:22:1.enabled +function/2/cmp.config.set_cmdline +function/1/cmp.config.set_onetime +function/0/cmp.config.is_native_menu +function/1/cmp.config.get_source_config +number/cmp.config.onetime.revision +function/1/cmp.config.normalize +function/0/cmp.config.global.enabled +number/cmp.config.global.revision +string/cmp.config.global.preselect +function/0/cmp.config.enabled +function/2/cmp.config.set_filetype +function/0/cmp.config.get +function/2/cmp.config.set_buffer +function/1/cmp.config.set_global +function/0/cmp.utils.feedkeys.call.callbacks.57 +function/1/cmp.utils.autocmd.emit +function/0/cmp.utils.autocmd.events.CursorMovedI.1 +function/0/cmp.utils.autocmd.events.CmdlineLeave.1 +function/0/cmp.utils.autocmd.events.TextChangedI.1 +function/0/cmp.utils.autocmd.events.CompleteChanged.1 +function/0/cmp.utils.autocmd.events.CompleteChanged.2 +function/0/cmp.utils.autocmd.events.CompleteChanged.3 +function/0/cmp.utils.autocmd.events.InsertEnter.1 +function/0/cmp.utils.autocmd.events.CmdlineEnter.1 +function/0/cmp.utils.autocmd.events.ColorScheme.1 +function/0/cmp.utils.autocmd.events.CmdlineChanged.1 +function/0/cmp.utils.autocmd.events.TextChangedP.1 +function/0/cmp.utils.autocmd.events.InsertLeave.1 +number/cmp.utils.autocmd.group +function/2/cmp.utils.autocmd.subscribe +function/3/nvim-tree.explorer.node-builders.folder +function/3/nvim-tree.explorer.node-builders.link +function/1/nvim-tree.explorer.node-builders.is_executable +function/3/nvim-tree.explorer.node-builders.file +function/1/luasnip.loaders.from_lua._load_lazy_loaded +function/1/luasnip.loaders.from_lua.lazy_load +function/1/luasnip.loaders.from_lua.load +function/1/luasnip.loaders.from_lua._load_lazy_loaded_ft +function/1/luasnip.loaders.from_lua._reload_file +function/0/luasnip.loaders.from_lua.edit_snippet_files +function/1/cmp.utils.misc.once +function/2/cmp.utils.misc.rep +function/1/cmp.utils.misc.copy +number/cmp.utils.misc.id.group.entry.new +number/cmp.utils.misc.id.group.cmp.utils.feedkeys.call +number/cmp.utils.misc.id.group.cmp.utils.window.new +number/cmp.utils.misc.id.group.cmp.source.new +number/cmp.utils.misc.id.group.cmp.context.new +function/2/cmp.utils.misc.bool +boolean/cmp.utils.misc.redraw.doing +string/cmp.utils.misc.redraw.incsearch_redraw_keys +boolean/cmp.utils.misc.redraw.force +function/2/cmp.utils.misc.deprecated +function/2/cmp.utils.misc.to_utfindex +function/1/cmp.utils.misc.empty +function/2/cmp.utils.misc.to_vimindex +function/2/cmp.utils.misc.merge +function/2/cmp.utils.misc.concat +userdata/cmp.utils.misc.none +function/3/cmp.utils.misc.set +function/2/cmp.utils.async.throttle +function/0/cmp.utils.async.step +function/2/cmp.utils.async.timeout +function/0/cmp.utils.async.dedup +function/1/cmp.utils.async.debounce_next_tick_by_keymap +function/1/cmp.utils.async.debounce_next_tick +function/2/cmp.utils.async.sync +function/1/nvim-tree.actions.finders.find-file.fn +boolean/package.loaded.cmp.types.vim +function/0/luasnip.util.path.normalize +function/1/luasnip.util.path.read_file +function/1/luasnip.util.path.exists +function/2/luasnip.util.path.basename +function/1/luasnip.util.path.scandir +function/0/luasnip.util.path.join +function/2/luasnip.util.path.async_read_file +function/1/luasnip.util.path.expand +function/0/package.loaded.cmp.config.sources +function/0/cmp_luasnip.clear_cache +function/3/cmp_luasnip.complete +function/1/cmp_luasnip.is_available +function/0/cmp_luasnip.refresh +function/3/cmp_luasnip.execute +function/0/cmp_luasnip.get_keyword_pattern +function/1/cmp_luasnip.get_debug_name +function/3/cmp_luasnip.resolve +function/0/cmp_luasnip.new +function/1/lspconfig.configs.svelte.setup +boolean/lspconfig.configs.svelte.autostart +function/1/lspconfig.configs.svelte.make_config +string/lspconfig.configs.svelte.filetypes.1 +function/0/lspconfig.configs.svelte.manager.clients +function/1/lspconfig.configs.svelte.manager.try_add +function/3/lspconfig.configs.svelte.manager.add +function/1/lspconfig.configs.svelte.manager.try_add_wrapper +string/lspconfig.configs.svelte.cmd.1 +string/lspconfig.configs.svelte.cmd.2 +string/lspconfig.configs.svelte.document_config.docs.default_config.root_dir +string/lspconfig.configs.svelte.document_config.docs.description +function/1/lspconfig.configs.svelte.document_config.default_config.root_dir +function/1/lspconfig.configs.svelte.get_root_dir +function/0/lspconfig.configs.svelte.launch +function/2/lspconfig.configs.svelte._setup_buffer +string/lspconfig.configs.svelte.name +function/1/lspconfig.configs.html.setup +boolean/lspconfig.configs.html.autostart +function/1/lspconfig.configs.html.make_config +string/lspconfig.configs.html.filetypes.1 +function/0/lspconfig.configs.html.manager.clients +function/1/lspconfig.configs.html.manager.try_add +function/3/lspconfig.configs.html.manager.add +function/1/lspconfig.configs.html.manager.try_add_wrapper +string/lspconfig.configs.html.cmd.1 +string/lspconfig.configs.html.cmd.2 +string/lspconfig.configs.html.document_config.docs.description +function/1/lspconfig.configs.html.document_config.default_config.root_dir +boolean/lspconfig.configs.html.document_config.default_config.init_options.provideFormatter +boolean/lspconfig.configs.html.document_config.default_config.init_options.embeddedLanguages.css +boolean/lspconfig.configs.html.document_config.default_config.init_options.embeddedLanguages.javascript +string/lspconfig.configs.html.document_config.default_config.init_options.configurationSection.1 +string/lspconfig.configs.html.document_config.default_config.init_options.configurationSection.2 +string/lspconfig.configs.html.document_config.default_config.init_options.configurationSection.3 +boolean/lspconfig.configs.html.document_config.default_config.single_file_support +function/1/lspconfig.configs.html.get_root_dir +function/0/lspconfig.configs.html.launch +function/2/lspconfig.configs.html._setup_buffer +string/lspconfig.configs.html.name +function/1/lspconfig.configs.cssls.setup +boolean/lspconfig.configs.cssls.autostart +function/1/lspconfig.configs.cssls.make_config +string/lspconfig.configs.cssls.filetypes.1 +string/lspconfig.configs.cssls.filetypes.2 +string/lspconfig.configs.cssls.filetypes.3 +function/0/lspconfig.configs.cssls.manager.clients +function/1/lspconfig.configs.cssls.manager.try_add +function/3/lspconfig.configs.cssls.manager.add +function/1/lspconfig.configs.cssls.manager.try_add_wrapper +string/lspconfig.configs.cssls.cmd.1 +string/lspconfig.configs.cssls.cmd.2 +string/lspconfig.configs.cssls.document_config.docs.default_config.root_dir +string/lspconfig.configs.cssls.document_config.docs.description +function/1/lspconfig.configs.cssls.document_config.default_config.root_dir +boolean/lspconfig.configs.cssls.document_config.default_config.settings.scss.validate +boolean/lspconfig.configs.cssls.document_config.default_config.settings.css.validate +boolean/lspconfig.configs.cssls.document_config.default_config.settings.less.validate +boolean/lspconfig.configs.cssls.document_config.default_config.single_file_support +function/1/lspconfig.configs.cssls.get_root_dir +function/0/lspconfig.configs.cssls.launch +function/2/lspconfig.configs.cssls._setup_buffer +string/lspconfig.configs.cssls.name +function/1/lspconfig.configs.tsserver.setup +boolean/lspconfig.configs.tsserver.autostart +function/1/lspconfig.configs.tsserver.make_config +string/lspconfig.configs.tsserver.filetypes.1 +string/lspconfig.configs.tsserver.filetypes.2 +string/lspconfig.configs.tsserver.filetypes.3 +string/lspconfig.configs.tsserver.filetypes.4 +string/lspconfig.configs.tsserver.filetypes.5 +string/lspconfig.configs.tsserver.filetypes.6 +function/0/lspconfig.configs.tsserver.manager.clients +function/1/lspconfig.configs.tsserver.manager.try_add +function/3/lspconfig.configs.tsserver.manager.add +function/1/lspconfig.configs.tsserver.manager.try_add_wrapper +string/lspconfig.configs.tsserver.cmd.1 +string/lspconfig.configs.tsserver.cmd.2 +string/lspconfig.configs.tsserver.document_config.docs.default_config.root_dir +string/lspconfig.configs.tsserver.document_config.docs.description +function/1/lspconfig.configs.tsserver.document_config.default_config.root_dir +boolean/lspconfig.configs.tsserver.document_config.default_config.single_file_support +string/lspconfig.configs.tsserver.document_config.default_config.init_options.hostInfo +function/1/lspconfig.configs.tsserver.get_root_dir +function/0/lspconfig.configs.tsserver.launch +function/2/lspconfig.configs.tsserver._setup_buffer +string/lspconfig.configs.tsserver.name +function/1/lspconfig.configs.jsonls.setup +boolean/lspconfig.configs.jsonls.autostart +function/1/lspconfig.configs.jsonls.make_config +string/lspconfig.configs.jsonls.filetypes.1 +string/lspconfig.configs.jsonls.filetypes.2 +function/0/lspconfig.configs.jsonls.manager.clients +function/1/lspconfig.configs.jsonls.manager.try_add +function/3/lspconfig.configs.jsonls.manager.add +function/1/lspconfig.configs.jsonls.manager.try_add_wrapper +string/lspconfig.configs.jsonls.cmd.1 +string/lspconfig.configs.jsonls.cmd.2 +string/lspconfig.configs.jsonls.document_config.docs.default_config.root_dir +string/lspconfig.configs.jsonls.document_config.docs.description +function/1/lspconfig.configs.jsonls.document_config.default_config.root_dir +boolean/lspconfig.configs.jsonls.document_config.default_config.single_file_support +boolean/lspconfig.configs.jsonls.document_config.default_config.init_options.provideFormatter +function/1/lspconfig.configs.jsonls.get_root_dir +function/0/lspconfig.configs.jsonls.launch +function/2/lspconfig.configs.jsonls._setup_buffer +string/lspconfig.configs.jsonls.name +function/1/lspconfig.configs.nil_ls.setup +boolean/lspconfig.configs.nil_ls.autostart +function/1/lspconfig.configs.nil_ls.make_config +function/0/lspconfig.configs.nil_ls.manager.clients +function/1/lspconfig.configs.nil_ls.manager.try_add +function/3/lspconfig.configs.nil_ls.manager.add +function/1/lspconfig.configs.nil_ls.manager.try_add_wrapper +string/lspconfig.configs.nil_ls.document_config.docs.default_config.root_dir +string/lspconfig.configs.nil_ls.document_config.docs.description +function/1/lspconfig.configs.nil_ls.document_config.default_config.root_dir +boolean/lspconfig.configs.nil_ls.document_config.default_config.single_file_support +function/1/lspconfig.configs.nil_ls.get_root_dir +function/0/lspconfig.configs.nil_ls.launch +function/2/lspconfig.configs.nil_ls._setup_buffer +string/lspconfig.configs.nil_ls.name +function/1/lspconfig.configs.taplo.setup +boolean/lspconfig.configs.taplo.autostart +function/1/lspconfig.configs.taplo.make_config +string/lspconfig.configs.taplo.filetypes.1 +function/0/lspconfig.configs.taplo.manager.clients +function/1/lspconfig.configs.taplo.manager.try_add +function/3/lspconfig.configs.taplo.manager.add +function/1/lspconfig.configs.taplo.manager.try_add_wrapper +string/lspconfig.configs.taplo.cmd.1 +string/lspconfig.configs.taplo.cmd.2 +string/lspconfig.configs.taplo.cmd.3 +string/lspconfig.configs.taplo.document_config.docs.default_config.root_dir +string/lspconfig.configs.taplo.document_config.docs.description +function/1/lspconfig.configs.taplo.document_config.default_config.root_dir +boolean/lspconfig.configs.taplo.document_config.default_config.single_file_support +function/1/lspconfig.configs.taplo.get_root_dir +function/0/lspconfig.configs.taplo.launch +function/2/lspconfig.configs.taplo._setup_buffer +string/lspconfig.configs.taplo.name +function/1/lspconfig.configs.marksman.setup +boolean/lspconfig.configs.marksman.autostart +function/1/lspconfig.configs.marksman.make_config +string/lspconfig.configs.marksman.filetypes.1 +function/0/lspconfig.configs.marksman.manager.clients +function/1/lspconfig.configs.marksman.manager.try_add +function/3/lspconfig.configs.marksman.manager.add +function/1/lspconfig.configs.marksman.manager.try_add_wrapper +string/lspconfig.configs.marksman.cmd.1 +string/lspconfig.configs.marksman.cmd.2 +string/lspconfig.configs.marksman.document_config.docs.default_config.root_dir +string/lspconfig.configs.marksman.document_config.docs.description +function/1/lspconfig.configs.marksman.document_config.default_config.root_dir +boolean/lspconfig.configs.marksman.document_config.default_config.single_file_support +function/1/lspconfig.configs.marksman.get_root_dir +function/0/lspconfig.configs.marksman.launch +function/2/lspconfig.configs.marksman._setup_buffer +string/lspconfig.configs.marksman.name +function/1/lspconfig.configs.bashls.setup +boolean/lspconfig.configs.bashls.autostart +function/1/lspconfig.configs.bashls.make_config +string/lspconfig.configs.bashls.filetypes.1 +function/0/lspconfig.configs.bashls.manager.clients +function/1/lspconfig.configs.bashls.manager.try_add +function/3/lspconfig.configs.bashls.manager.add +function/1/lspconfig.configs.bashls.manager.try_add_wrapper +string/lspconfig.configs.bashls.cmd.1 +string/lspconfig.configs.bashls.cmd.2 +string/lspconfig.configs.bashls.document_config.docs.default_config.root_dir +string/lspconfig.configs.bashls.document_config.docs.description +function/1/lspconfig.configs.bashls.document_config.default_config.root_dir +string/lspconfig.configs.bashls.document_config.default_config.cmd_env.GLOB_PATTERN +boolean/lspconfig.configs.bashls.document_config.default_config.single_file_support +function/1/lspconfig.configs.bashls.get_root_dir +function/0/lspconfig.configs.bashls.launch +function/2/lspconfig.configs.bashls._setup_buffer +string/lspconfig.configs.bashls.name +function/1/lspconfig.configs.clangd.setup +boolean/lspconfig.configs.clangd.autostart +function/1/lspconfig.configs.clangd.make_config +function/0/lspconfig.configs.clangd.manager.clients +function/1/lspconfig.configs.clangd.manager.try_add +function/3/lspconfig.configs.clangd.manager.add +function/1/lspconfig.configs.clangd.manager.try_add_wrapper +function/1/lspconfig.configs.clangd.get_root_dir +function/0/lspconfig.configs.clangd.launch +function/2/lspconfig.configs.clangd._setup_buffer +string/lspconfig.configs.clangd.name +function/1/lspconfig.configs.pylsp.setup +boolean/lspconfig.configs.pylsp.autostart +function/1/lspconfig.configs.pylsp.make_config +function/0/lspconfig.configs.pylsp.manager.clients +function/1/lspconfig.configs.pylsp.manager.try_add +function/3/lspconfig.configs.pylsp.manager.add +function/1/lspconfig.configs.pylsp.manager.try_add_wrapper +function/1/lspconfig.configs.pylsp.get_root_dir +function/0/lspconfig.configs.pylsp.launch +function/2/lspconfig.configs.pylsp._setup_buffer +string/lspconfig.configs.pylsp.name +function/1/lspconfig.configs.rust_analyzer.setup +boolean/lspconfig.configs.rust_analyzer.autostart +function/0/lspconfig.configs.rust_analyzer.commands.CargoReload.1 +string/lspconfig.configs.rust_analyzer.commands.CargoReload.description +function/1/lspconfig.configs.rust_analyzer.make_config +string/lspconfig.configs.rust_analyzer.filetypes.1 +function/0/lspconfig.configs.rust_analyzer.manager.clients +function/1/lspconfig.configs.rust_analyzer.manager.try_add +function/3/lspconfig.configs.rust_analyzer.manager.add +function/1/lspconfig.configs.rust_analyzer.manager.try_add_wrapper +string/lspconfig.configs.rust_analyzer.cmd.1 +string/lspconfig.configs.rust_analyzer.document_config.docs.default_config.root_dir +string/lspconfig.configs.rust_analyzer.document_config.docs.description +function/1/lspconfig.configs.rust_analyzer.document_config.default_config.root_dir +function/1/lspconfig.configs.rust_analyzer.get_root_dir +function/0/lspconfig.configs.rust_analyzer.launch +function/2/lspconfig.configs.rust_analyzer._setup_buffer +string/lspconfig.configs.rust_analyzer.name +string/cmp.utils.highlight.keys.1 +string/cmp.utils.highlight.keys.2 +string/cmp.utils.highlight.keys.3 +string/cmp.utils.highlight.keys.4 +string/cmp.utils.highlight.keys.5 +string/cmp.utils.highlight.keys.6 +string/cmp.utils.highlight.keys.7 +string/cmp.utils.highlight.keys.8 +string/cmp.utils.highlight.keys.9 +function/3/cmp.utils.highlight.inherit +function/0/luasnip.loaders._caches.cleanup +boolean/luasnip.loaders._caches.vscode.lazy_loaded_ft. +boolean/luasnip.loaders._caches.vscode.lazy_loaded_ft.nix +boolean/luasnip.loaders._caches.vscode.lazy_loaded_ft.all +boolean/luasnip.loaders._caches.vscode.lazy_loaded_ft.cmp_menu +boolean/luasnip.loaders._caches.vscode.lazy_loaded_ft.lua +boolean/luasnip.loaders._caches.vscode.lazy_loaded_ft.vim +boolean/luasnip.loaders._caches.vscode.lazy_loaded_ft.WhichKey +boolean/luasnip.loaders._caches.vscode.lazy_loaded_ft.cmp_docs +boolean/luasnip.loaders._caches.vscode.lazy_loaded_ft.help +boolean/luasnip.loaders._caches.lua.lazy_loaded_ft. +boolean/luasnip.loaders._caches.lua.lazy_loaded_ft.nix +boolean/luasnip.loaders._caches.lua.lazy_loaded_ft.all +boolean/luasnip.loaders._caches.lua.lazy_loaded_ft.cmp_menu +boolean/luasnip.loaders._caches.lua.lazy_loaded_ft.lua +boolean/luasnip.loaders._caches.lua.lazy_loaded_ft.vim +boolean/luasnip.loaders._caches.lua.lazy_loaded_ft.WhichKey +boolean/luasnip.loaders._caches.lua.lazy_loaded_ft.cmp_docs +boolean/luasnip.loaders._caches.lua.lazy_loaded_ft.help +boolean/luasnip.loaders._caches.snipmate.lazy_loaded_ft. +boolean/luasnip.loaders._caches.snipmate.lazy_loaded_ft.nix +boolean/luasnip.loaders._caches.snipmate.lazy_loaded_ft.all +boolean/luasnip.loaders._caches.snipmate.lazy_loaded_ft.cmp_menu +boolean/luasnip.loaders._caches.snipmate.lazy_loaded_ft.lua +boolean/luasnip.loaders._caches.snipmate.lazy_loaded_ft.vim +boolean/luasnip.loaders._caches.snipmate.lazy_loaded_ft.WhichKey +boolean/luasnip.loaders._caches.snipmate.lazy_loaded_ft.cmp_docs +boolean/luasnip.loaders._caches.snipmate.lazy_loaded_ft.help +boolean/package.loaded.vim._init_packages +function/1/nvim-autopairs.completion.cmp.on_confirm_done +boolean/nvim-autopairs.completion.cmp.filetypes.haskell +function/5/nvim-autopairs.completion.cmp.filetypes.clojurescript.(.handler +number/nvim-autopairs.completion.cmp.filetypes.clojurescript.(.kind.1 +number/nvim-autopairs.completion.cmp.filetypes.clojurescript.(.kind.2 +function/5/nvim-autopairs.completion.cmp.filetypes.janet.(.handler +number/nvim-autopairs.completion.cmp.filetypes.janet.(.kind.1 +number/nvim-autopairs.completion.cmp.filetypes.janet.(.kind.2 +boolean/nvim-autopairs.completion.cmp.filetypes.purescript +function/5/nvim-autopairs.completion.cmp.filetypes.clojure.(.handler +number/nvim-autopairs.completion.cmp.filetypes.clojure.(.kind.1 +number/nvim-autopairs.completion.cmp.filetypes.clojure.(.kind.2 +function/5/nvim-autopairs.completion.cmp.filetypes.*.(.handler +number/nvim-autopairs.completion.cmp.filetypes.*.(.kind.1 +number/nvim-autopairs.completion.cmp.filetypes.*.(.kind.2 +function/5/nvim-autopairs.completion.cmp.filetypes.fennel.(.handler +number/nvim-autopairs.completion.cmp.filetypes.fennel.(.kind.1 +number/nvim-autopairs.completion.cmp.filetypes.fennel.(.kind.2 +boolean/nvim-autopairs.completion.cmp.filetypes.tex +function/1/nvim-autopairs.get_buf_rules +function/2/nvim-autopairs.autopairs_map +function/0/nvim-autopairs.disable +function/1/nvim-autopairs.force_attach +function/1/nvim-autopairs.on_attach +function/2/nvim-autopairs.autopairs_insert +function/2/nvim-autopairs.set_buf_rule +function/1/nvim-autopairs.add_rule +function/1/nvim-autopairs.add_rules +function/1/nvim-autopairs.get_rule +function/1/nvim-autopairs.remove_rule +function/1/nvim-autopairs.autopairs_cr +function/1/nvim-autopairs.setup +function/0/nvim-autopairs.clear_rules +function/0/nvim-autopairs.autopairs_closequote_expr +function/0/nvim-autopairs.enable +function/0/nvim-autopairs.check_break_line_char +function/0/nvim-autopairs.completion_confirm +string/nvim-autopairs.config.disable_filetype.1 +string/nvim-autopairs.config.disable_filetype.2 +boolean/nvim-autopairs.config.map_bs +boolean/nvim-autopairs.config.map_c_h +boolean/nvim-autopairs.config.map_c_w +boolean/nvim-autopairs.config.map_cr +boolean/nvim-autopairs.config.disable_in_macro +boolean/nvim-autopairs.config.disable_in_visualblock +boolean/nvim-autopairs.config.disable_in_replace_mode +string/nvim-autopairs.config.ignored_next_char +boolean/nvim-autopairs.config.rules.1.is_regex +string/nvim-autopairs.config.rules.1.end_pair +boolean/nvim-autopairs.config.rules.1.end_pair_func +function/0/nvim-autopairs.config.rules.1.cr_cond.1 +boolean/nvim-autopairs.config.rules.1.is_multibyte +string/nvim-autopairs.config.rules.1.start_pair +string/nvim-autopairs.config.rules.1.filetypes.1 +boolean/nvim-autopairs.config.rules.1.is_endwise +string/nvim-autopairs.config.rules.1.key_map +boolean/nvim-autopairs.config.rules.2.is_regex +string/nvim-autopairs.config.rules.2.end_pair +boolean/nvim-autopairs.config.rules.2.end_pair_func +boolean/nvim-autopairs.config.rules.2.is_multibyte +string/nvim-autopairs.config.rules.2.start_pair +string/nvim-autopairs.config.rules.2.filetypes.1 +string/nvim-autopairs.config.rules.2.filetypes.2 +string/nvim-autopairs.config.rules.2.filetypes.3 +string/nvim-autopairs.config.rules.2.filetypes.4 +string/nvim-autopairs.config.rules.2.filetypes.5 +boolean/nvim-autopairs.config.rules.2.is_endwise +string/nvim-autopairs.config.rules.2.key_map +boolean/nvim-autopairs.config.rules.3.is_regex +string/nvim-autopairs.config.rules.3.end_pair +boolean/nvim-autopairs.config.rules.3.end_pair_func +boolean/nvim-autopairs.config.rules.3.del_cond +boolean/nvim-autopairs.config.rules.3.pair_cond +boolean/nvim-autopairs.config.rules.3.is_multibyte +boolean/nvim-autopairs.config.rules.3.move_cond +string/nvim-autopairs.config.rules.3.start_pair +string/nvim-autopairs.config.rules.3.filetypes.1 +string/nvim-autopairs.config.rules.3.filetypes.2 +string/nvim-autopairs.config.rules.3.filetypes.3 +string/nvim-autopairs.config.rules.3.filetypes.4 +string/nvim-autopairs.config.rules.3.filetypes.5 +boolean/nvim-autopairs.config.rules.3.is_endwise +string/nvim-autopairs.config.rules.3.key_map +boolean/nvim-autopairs.config.rules.4.is_regex +string/nvim-autopairs.config.rules.4.end_pair +boolean/nvim-autopairs.config.rules.4.end_pair_func +function/1/nvim-autopairs.config.rules.4.pair_cond.1 +boolean/nvim-autopairs.config.rules.4.is_multibyte +string/nvim-autopairs.config.rules.4.start_pair +string/nvim-autopairs.config.rules.4.filetypes.1 +string/nvim-autopairs.config.rules.4.filetypes.2 +string/nvim-autopairs.config.rules.4.filetypes.3 +string/nvim-autopairs.config.rules.4.filetypes.4 +boolean/nvim-autopairs.config.rules.4.is_endwise +string/nvim-autopairs.config.rules.4.key_map +boolean/nvim-autopairs.config.rules.5.is_regex +string/nvim-autopairs.config.rules.5.end_pair +boolean/nvim-autopairs.config.rules.5.end_pair_func +function/1/nvim-autopairs.config.rules.5.pair_cond.1 +boolean/nvim-autopairs.config.rules.5.is_multibyte +string/nvim-autopairs.config.rules.5.start_pair +string/nvim-autopairs.config.rules.5.filetypes.1 +boolean/nvim-autopairs.config.rules.5.is_endwise +string/nvim-autopairs.config.rules.5.key_map +boolean/nvim-autopairs.config.rules.6.is_regex +boolean/nvim-autopairs.config.rules.6.is_undo +string/nvim-autopairs.config.rules.6.end_pair +boolean/nvim-autopairs.config.rules.6.end_pair_func +function/1/nvim-autopairs.config.rules.6.pair_cond.1 +function/1/nvim-autopairs.config.rules.6.pair_cond.2 +function/1/nvim-autopairs.config.rules.6.pair_cond.3 +boolean/nvim-autopairs.config.rules.6.is_multibyte +function/1/nvim-autopairs.config.rules.6.move_cond.1 +string/nvim-autopairs.config.rules.6.not_filetypes.1 +string/nvim-autopairs.config.rules.6.start_pair +boolean/nvim-autopairs.config.rules.6.is_endwise +string/nvim-autopairs.config.rules.6.key_map +boolean/nvim-autopairs.config.rules.7.is_regex +string/nvim-autopairs.config.rules.7.end_pair +boolean/nvim-autopairs.config.rules.7.end_pair_func +function/1/nvim-autopairs.config.rules.7.pair_cond.1 +function/1/nvim-autopairs.config.rules.7.pair_cond.2 +function/1/nvim-autopairs.config.rules.7.pair_cond.3 +function/1/nvim-autopairs.config.rules.7.pair_cond.4 +boolean/nvim-autopairs.config.rules.7.is_multibyte +function/1/nvim-autopairs.config.rules.7.move_cond.1 +boolean/nvim-autopairs.config.rules.7.is_undo +string/nvim-autopairs.config.rules.7.start_pair +string/nvim-autopairs.config.rules.7.filetypes.1 +boolean/nvim-autopairs.config.rules.7.is_endwise +string/nvim-autopairs.config.rules.7.key_map +boolean/nvim-autopairs.config.rules.8.is_regex +string/nvim-autopairs.config.rules.8.end_pair +boolean/nvim-autopairs.config.rules.8.end_pair_func +function/1/nvim-autopairs.config.rules.8.pair_cond.1 +function/1/nvim-autopairs.config.rules.8.pair_cond.2 +boolean/nvim-autopairs.config.rules.8.is_multibyte +boolean/nvim-autopairs.config.rules.8.is_undo +function/1/nvim-autopairs.config.rules.8.move_cond.1 +string/nvim-autopairs.config.rules.8.start_pair +boolean/nvim-autopairs.config.rules.8.is_endwise +string/nvim-autopairs.config.rules.8.key_map +boolean/nvim-autopairs.config.rules.9.is_regex +boolean/nvim-autopairs.config.rules.9.is_undo +string/nvim-autopairs.config.rules.9.end_pair +boolean/nvim-autopairs.config.rules.9.end_pair_func +function/1/nvim-autopairs.config.rules.9.pair_cond.1 +function/1/nvim-autopairs.config.rules.9.pair_cond.2 +boolean/nvim-autopairs.config.rules.9.is_multibyte +function/1/nvim-autopairs.config.rules.9.move_cond.1 +string/nvim-autopairs.config.rules.9.not_filetypes.1 +string/nvim-autopairs.config.rules.9.start_pair +boolean/nvim-autopairs.config.rules.9.is_endwise +string/nvim-autopairs.config.rules.9.key_map +boolean/nvim-autopairs.config.rules.10.is_regex +string/nvim-autopairs.config.rules.10.end_pair +boolean/nvim-autopairs.config.rules.10.end_pair_func +function/1/nvim-autopairs.config.rules.10.pair_cond.1 +function/1/nvim-autopairs.config.rules.10.pair_cond.2 +function/1/nvim-autopairs.config.rules.10.pair_cond.3 +boolean/nvim-autopairs.config.rules.10.is_multibyte +function/1/nvim-autopairs.config.rules.10.move_cond.1 +boolean/nvim-autopairs.config.rules.10.is_undo +string/nvim-autopairs.config.rules.10.start_pair +string/nvim-autopairs.config.rules.10.filetypes.1 +boolean/nvim-autopairs.config.rules.10.is_endwise +string/nvim-autopairs.config.rules.10.key_map +boolean/nvim-autopairs.config.rules.11.is_regex +string/nvim-autopairs.config.rules.11.end_pair +boolean/nvim-autopairs.config.rules.11.end_pair_func +function/1/nvim-autopairs.config.rules.11.pair_cond.1 +function/1/nvim-autopairs.config.rules.11.pair_cond.2 +function/1/nvim-autopairs.config.rules.11.pair_cond.3 +boolean/nvim-autopairs.config.rules.11.is_multibyte +boolean/nvim-autopairs.config.rules.11.is_undo +function/1/nvim-autopairs.config.rules.11.move_cond.1 +function/1/nvim-autopairs.config.rules.11.move_cond.2 +string/nvim-autopairs.config.rules.11.start_pair +boolean/nvim-autopairs.config.rules.11.is_endwise +string/nvim-autopairs.config.rules.11.key_map +boolean/nvim-autopairs.config.rules.12.is_regex +string/nvim-autopairs.config.rules.12.end_pair +boolean/nvim-autopairs.config.rules.12.end_pair_func +function/1/nvim-autopairs.config.rules.12.pair_cond.1 +function/1/nvim-autopairs.config.rules.12.pair_cond.2 +function/1/nvim-autopairs.config.rules.12.pair_cond.3 +boolean/nvim-autopairs.config.rules.12.is_multibyte +boolean/nvim-autopairs.config.rules.12.is_undo +function/1/nvim-autopairs.config.rules.12.move_cond.1 +function/1/nvim-autopairs.config.rules.12.move_cond.2 +string/nvim-autopairs.config.rules.12.start_pair +boolean/nvim-autopairs.config.rules.12.is_endwise +string/nvim-autopairs.config.rules.12.key_map +boolean/nvim-autopairs.config.rules.13.is_regex +string/nvim-autopairs.config.rules.13.end_pair +boolean/nvim-autopairs.config.rules.13.end_pair_func +function/1/nvim-autopairs.config.rules.13.pair_cond.1 +function/1/nvim-autopairs.config.rules.13.pair_cond.2 +function/1/nvim-autopairs.config.rules.13.pair_cond.3 +boolean/nvim-autopairs.config.rules.13.is_multibyte +boolean/nvim-autopairs.config.rules.13.is_undo +function/1/nvim-autopairs.config.rules.13.move_cond.1 +function/1/nvim-autopairs.config.rules.13.move_cond.2 +string/nvim-autopairs.config.rules.13.start_pair +boolean/nvim-autopairs.config.rules.13.is_endwise +string/nvim-autopairs.config.rules.13.key_map +boolean/nvim-autopairs.config.rules.14.is_regex +string/nvim-autopairs.config.rules.14.end_pair +boolean/nvim-autopairs.config.rules.14.end_pair_func +boolean/nvim-autopairs.config.rules.14.del_cond +boolean/nvim-autopairs.config.rules.14.pair_cond +boolean/nvim-autopairs.config.rules.14.is_multibyte +boolean/nvim-autopairs.config.rules.14.move_cond +string/nvim-autopairs.config.rules.14.start_pair +string/nvim-autopairs.config.rules.14.filetypes.1 +string/nvim-autopairs.config.rules.14.filetypes.2 +string/nvim-autopairs.config.rules.14.filetypes.3 +string/nvim-autopairs.config.rules.14.filetypes.4 +string/nvim-autopairs.config.rules.14.filetypes.5 +string/nvim-autopairs.config.rules.14.filetypes.6 +string/nvim-autopairs.config.rules.14.filetypes.7 +string/nvim-autopairs.config.rules.14.filetypes.8 +string/nvim-autopairs.config.rules.14.filetypes.9 +boolean/nvim-autopairs.config.rules.14.is_endwise +string/nvim-autopairs.config.rules.14.key_map +boolean/nvim-autopairs.config.break_undo +boolean/nvim-autopairs.config.check_ts +boolean/nvim-autopairs.config.enable_moveright +boolean/nvim-autopairs.config.enable_afterquote +boolean/nvim-autopairs.config.enable_check_bracket_line +boolean/nvim-autopairs.config.enable_bracket_in_quote +boolean/nvim-autopairs.config.enable_abbr +string/nvim-autopairs.config.ts_config.javascript.1 +string/nvim-autopairs.config.ts_config.javascript.2 +string/nvim-autopairs.config.ts_config.lua.1 +string/nvim-autopairs.config.ts_config.lua.2 +function/1/nvim-autopairs.esc +function/1/nvim-autopairs.autopairs_c_w +function/0/nvim-autopairs.map_cr +function/1/nvim-autopairs.autopairs_c_h +function/1/nvim-autopairs.autopairs_bs +function/2/nvim-autopairs.autopairs_afterquote +string/nvim-autopairs.state.expr_quote +boolean/nvim-autopairs.state.disabled +function/1/vim.shared.tbl_flatten +function/4/vim.shared.list_extend +function/0/vim.shared._getvar +function/0/vim.shared._setvar +function/1/vim.shared.tbl_deep_extend +function/0/vim.shared.spell.check +function/0/vim.shared.iconv +function/0/vim.shared.api.nvim_win_get_tabpage +function/0/vim.shared.api.nvim_win_get_number +function/0/vim.shared.api.nvim_win_is_valid +function/0/vim.shared.api.nvim_win_hide +function/0/vim.shared.api.nvim_win_close +function/0/vim.shared.api.nvim_win_call +function/0/vim.shared.api.nvim_win_set_hl_ns +function/0/vim.shared.api.nvim_get_autocmds +function/0/vim.shared.api.nvim_create_autocmd +function/0/vim.shared.api.nvim_del_autocmd +function/0/vim.shared.api.nvim_clear_autocmds +function/0/vim.shared.api.nvim_create_augroup +function/0/vim.shared.api.nvim_del_augroup_by_id +function/0/vim.shared.api.nvim_del_augroup_by_name +function/0/vim.shared.api.nvim_exec_autocmds +function/0/vim.shared.api.nvim_buf_line_count +function/0/vim.shared.api.nvim_buf_attach +function/0/vim.shared.api.nvim__buf_redraw_range +function/0/vim.shared.api.nvim_buf_get_lines +function/0/vim.shared.api.nvim_buf_set_lines +function/0/vim.shared.api.nvim_buf_set_text +function/0/vim.shared.api.nvim_buf_get_text +function/0/vim.shared.api.nvim_buf_get_offset +function/0/vim.shared.api.nvim_buf_get_var +function/0/vim.shared.api.nvim_buf_get_changedtick +function/0/vim.shared.api.nvim_buf_get_keymap +function/0/vim.shared.api.nvim_buf_set_keymap +function/0/vim.shared.api.nvim_buf_del_keymap +function/0/vim.shared.api.nvim_buf_set_var +function/0/vim.shared.api.nvim_buf_del_var +function/0/vim.shared.api.nvim_buf_get_name +function/0/vim.shared.api.nvim_buf_set_name +function/0/vim.shared.api.nvim_buf_is_loaded +function/0/vim.shared.api.nvim_buf_delete +function/0/vim.shared.api.nvim_buf_is_valid +function/0/vim.shared.api.nvim_buf_del_mark +function/0/vim.shared.api.nvim_buf_set_mark +function/0/vim.shared.api.nvim_buf_get_mark +function/0/vim.shared.api.nvim_buf_call +function/0/vim.shared.api.nvim__buf_stats +function/0/vim.shared.api.nvim_parse_cmd +function/0/vim.shared.api.nvim_cmd +function/0/vim.shared.api.nvim_create_user_command +function/0/vim.shared.api.nvim_del_user_command +function/0/vim.shared.api.nvim_buf_create_user_command +function/0/vim.shared.api.nvim_buf_del_user_command +function/0/vim.shared.api.nvim_get_commands +function/0/vim.shared.api.nvim_buf_get_commands +function/0/vim.shared.api.nvim_command_output +function/0/vim.shared.api.nvim_buf_get_number +function/0/vim.shared.api.nvim_buf_clear_highlight +function/0/vim.shared.api.nvim_buf_set_virtual_text +function/0/vim.shared.api.nvim_create_namespace +function/0/vim.shared.api.nvim_get_namespaces +function/0/vim.shared.api.nvim_buf_get_extmark_by_id +function/0/vim.shared.api.nvim_buf_get_extmarks +function/0/vim.shared.api.nvim_buf_set_extmark +function/0/vim.shared.api.nvim_buf_del_extmark +function/0/vim.shared.api.nvim_buf_add_highlight +function/0/vim.shared.api.nvim_buf_clear_namespace +function/0/vim.shared.api.nvim_set_decoration_provider +function/0/vim.shared.api.nvim_get_option_value +function/0/vim.shared.api.nvim_set_option_value +function/0/vim.shared.api.nvim_get_all_options_info +function/0/vim.shared.api.nvim_get_option_info +function/0/vim.shared.api.nvim_set_option +function/0/vim.shared.api.nvim_get_option +function/0/vim.shared.api.nvim_buf_get_option +function/0/vim.shared.api.nvim_buf_set_option +function/0/vim.shared.api.nvim_win_get_option +function/0/vim.shared.api.nvim_win_set_option +function/0/vim.shared.api.nvim_tabpage_list_wins +function/0/vim.shared.api.nvim_tabpage_get_var +function/0/vim.shared.api.nvim_tabpage_set_var +function/0/vim.shared.api.nvim_tabpage_del_var +function/0/vim.shared.api.nvim_tabpage_get_win +function/0/vim.shared.api.nvim_tabpage_get_number +function/0/vim.shared.api.nvim_tabpage_is_valid +function/0/vim.shared.api.nvim_get_hl_by_name +function/0/vim.shared.api.nvim_get_hl_by_id +function/0/vim.shared.api.nvim_get_hl_id_by_name +function/0/vim.shared.api.nvim__get_hl_defs +function/0/vim.shared.api.nvim_set_hl +function/0/vim.shared.api.nvim_set_hl_ns +function/0/vim.shared.api.nvim_set_hl_ns_fast +function/0/vim.shared.api.nvim_feedkeys +function/0/vim.shared.api.nvim_input +function/0/vim.shared.api.nvim_input_mouse +function/0/vim.shared.api.nvim_replace_termcodes +function/0/vim.shared.api.nvim_notify +function/0/vim.shared.api.nvim_strwidth +function/0/vim.shared.api.nvim_list_runtime_paths +function/0/vim.shared.api.nvim__runtime_inspect +function/0/vim.shared.api.nvim_get_runtime_file +function/0/vim.shared.api.nvim__get_lib_dir +function/0/vim.shared.api.nvim__get_runtime +function/0/vim.shared.api.nvim_set_current_dir +function/0/vim.shared.api.nvim_get_current_line +function/0/vim.shared.api.nvim_set_current_line +function/0/vim.shared.api.nvim_del_current_line +function/0/vim.shared.api.nvim_get_var +function/0/vim.shared.api.nvim_set_var +function/0/vim.shared.api.nvim_del_var +function/0/vim.shared.api.nvim_get_vvar +function/0/vim.shared.api.nvim_set_vvar +function/0/vim.shared.api.nvim_echo +function/0/vim.shared.api.nvim_out_write +function/0/vim.shared.api.nvim_err_write +function/0/vim.shared.api.nvim_err_writeln +function/0/vim.shared.api.nvim_list_bufs +function/0/vim.shared.api.nvim_get_current_buf +function/0/vim.shared.api.nvim_set_current_buf +function/0/vim.shared.api.nvim_list_wins +function/0/vim.shared.api.nvim_get_current_win +function/0/vim.shared.api.nvim_set_current_win +function/0/vim.shared.api.nvim_create_buf +function/0/vim.shared.api.nvim_open_term +function/0/vim.shared.api.nvim_chan_send +function/0/vim.shared.api.nvim_list_tabpages +function/0/vim.shared.api.nvim_get_current_tabpage +function/0/vim.shared.api.nvim_set_current_tabpage +function/0/vim.shared.api.nvim_paste +function/0/vim.shared.api.nvim_put +function/0/vim.shared.api.nvim_get_color_by_name +function/0/vim.shared.api.nvim_get_color_map +function/0/vim.shared.api.nvim_get_context +function/0/vim.shared.api.nvim_load_context +function/0/vim.shared.api.nvim_get_mode +function/0/vim.shared.api.nvim_get_keymap +function/0/vim.shared.api.nvim_set_keymap +function/0/vim.shared.api.nvim_del_keymap +function/0/vim.shared.api.nvim_get_chan_info +function/0/vim.shared.api.nvim_list_chans +function/0/vim.shared.api.nvim__id +function/0/vim.shared.api.nvim__id_array +function/0/vim.shared.api.nvim__id_dictionary +function/0/vim.shared.api.nvim__id_float +function/0/vim.shared.api.nvim__stats +function/0/vim.shared.api.nvim_list_uis +function/0/vim.shared.api.nvim_get_proc_children +function/0/vim.shared.api.nvim_get_proc +function/0/vim.shared.api.nvim_select_popupmenu_item +function/0/vim.shared.api.nvim__inspect_cell +function/0/vim.shared.api.nvim__screenshot +function/0/vim.shared.api.nvim__unpack +function/0/vim.shared.api.nvim_del_mark +function/0/vim.shared.api.nvim_get_mark +function/0/vim.shared.api.nvim_eval_statusline +function/0/vim.shared.api.nvim_exec +function/0/vim.shared.api.nvim_command +function/0/vim.shared.api.nvim_eval +function/0/vim.shared.api.nvim_call_function +function/0/vim.shared.api.nvim_call_dict_function +function/0/vim.shared.api.nvim_parse_expression +function/0/vim.shared.api.nvim_open_win +function/0/vim.shared.api.nvim_win_set_config +function/0/vim.shared.api.nvim_win_get_config +function/0/vim.shared.api.nvim_win_get_buf +function/0/vim.shared.api.nvim_win_set_buf +function/0/vim.shared.api.nvim_win_get_cursor +function/0/vim.shared.api.nvim_win_set_cursor +function/0/vim.shared.api.nvim_win_get_height +function/0/vim.shared.api.nvim_win_set_height +function/0/vim.shared.api.nvim_win_get_width +function/0/vim.shared.api.nvim_win_set_width +function/0/vim.shared.api.nvim_win_get_var +function/0/vim.shared.api.nvim_win_set_var +function/0/vim.shared.api.nvim_win_del_var +function/0/vim.shared.api.nvim_win_get_position +boolean/vim.shared.type_idx +boolean/vim.shared.val_idx +string/vim.shared.types.5 +string/vim.shared.types.3 +number/vim.shared.types.array +number/vim.shared.types.dictionary +number/vim.shared.types.float +string/vim.shared.types.6 +function/3/vim.shared.highlight.create +number/vim.shared.highlight.priorities.syntax +number/vim.shared.highlight.priorities.user +number/vim.shared.highlight.priorities.diagnostics +number/vim.shared.highlight.priorities.treesitter +function/3/vim.shared.highlight.link +function/6/vim.shared.highlight.range +function/1/vim.shared.highlight.on_yank +function/0/vim.shared.schedule +function/0/vim.shared.in_fast_event +function/0/vim.shared.call +function/0/vim.shared.rpcrequest +function/0/vim.shared.rpcnotify +function/0/vim.shared.wait +function/0/vim.shared.ui_attach +function/0/vim.shared.ui_detach +function/0/vim.shared.is_thread +function/1/vim.shared._system +userdata/vim.shared.NIL +function/0/vim.shared._empty_dict_mt.__tostring +function/1/vim.shared.F.ok_or_nil +function/1/vim.shared.F.npcall +function/1/vim.shared.F.nil_wrap +function/0/vim.shared.F.pack_len +function/1/vim.shared.F.unpack_len +function/2/vim.shared.F.if_nil +userdata/vim.shared.json.null +userdata/vim.shared.json.empty_array +string/vim.shared.json._NAME +string/vim.shared.json._VERSION +function/0/vim.shared.json.decode +function/0/vim.shared.json.encode +function/0/vim.shared.json.encode_empty_table_as_object +function/0/vim.shared.json.decode_array_with_array_mt +function/0/vim.shared.json.encode_sparse_array +function/0/vim.shared.json.encode_max_depth +function/0/vim.shared.json.decode_max_depth +function/0/vim.shared.json.encode_number_precision +function/0/vim.shared.json.encode_keep_buffer +function/0/vim.shared.json.encode_invalid_numbers +function/0/vim.shared.json.decode_invalid_numbers +function/0/vim.shared.json.encode_escape_forward_slash +function/0/vim.shared.json.new +function/1/vim.shared.uri_from_bufnr +function/3/vim.shared.split +function/1/vim.shared.schedule_wrap +function/2/vim.shared.filetype.findany +function/3/vim.shared.filetype.getlines +function/1/vim.shared.filetype.match +function/1/vim.shared.filetype.add +function/2/vim.shared.filetype.matchregex +function/2/vim.shared.filetype.nextnonblank +function/3/vim.shared.keymap.del +function/4/vim.shared.keymap.set +function/2/vim.shared.diagnostic.config +function/2/vim.shared.diagnostic.disable +function/2/vim.shared.diagnostic.hide +function/1/vim.shared.diagnostic.toqflist +function/1/vim.shared.diagnostic.get_namespace +function/2/vim.shared.diagnostic._get_virt_text_chunks +function/1/vim.shared.diagnostic.fromqflist +function/2/vim.shared.diagnostic.handlers.underline.hide +function/4/vim.shared.diagnostic.handlers.underline.show +function/2/vim.shared.diagnostic.handlers.signs.hide +function/4/vim.shared.diagnostic.handlers.signs.show +function/2/vim.shared.diagnostic.handlers.virtual_text.hide +function/4/vim.shared.diagnostic.handlers.virtual_text.show +function/2/vim.shared.diagnostic.reset +function/4/vim.shared.diagnostic.set +function/4/vim.shared.diagnostic.show +function/1/vim.shared.diagnostic.open_float +function/2/vim.shared.diagnostic.get +function/2/vim.shared.diagnostic._execute_scheduled_display +function/1/vim.shared.diagnostic.setqflist +function/2/vim.shared.diagnostic.enable +string/vim.shared.diagnostic.severity.1 +string/vim.shared.diagnostic.severity.2 +string/vim.shared.diagnostic.severity.3 +string/vim.shared.diagnostic.severity.4 +number/vim.shared.diagnostic.severity.INFO +number/vim.shared.diagnostic.severity.I +number/vim.shared.diagnostic.severity.N +number/vim.shared.diagnostic.severity.W +number/vim.shared.diagnostic.severity.E +number/vim.shared.diagnostic.severity.WARN +number/vim.shared.diagnostic.severity.ERROR +number/vim.shared.diagnostic.severity.HINT +function/5/vim.shared.diagnostic.match +function/0/vim.shared.diagnostic.get_namespaces +function/1/vim.shared.diagnostic.get_prev +function/1/vim.shared.diagnostic.setloclist +function/1/vim.shared.diagnostic.get_prev_pos +function/1/vim.shared.diagnostic.get_next +function/1/vim.shared.diagnostic.get_next_pos +function/1/vim.shared.diagnostic.goto_next +function/1/vim.shared.diagnostic.goto_prev +function/2/vim.shared._expand_pat +function/2/vim.shared.on_key +function/1/vim.shared._expand_pat_get_parts +string/vim.shared._so_trails.1 +function/1/vim.shared._on_key +function/0/vim.shared._init_default_mappings +function/5/vim.shared.deprecate +function/4/vim.shared._cs_remote +function/0/vim.shared.pretty_print +function/2/vim.shared.startswith +boolean/vim.shared._submodules.lsp +boolean/vim.shared._submodules.treesitter +boolean/vim.shared._submodules.ui +boolean/vim.shared._submodules.fs +boolean/vim.shared._submodules.health +boolean/vim.shared._submodules.filetype +boolean/vim.shared._submodules.keymap +boolean/vim.shared._submodules.diagnostic +boolean/vim.shared._submodules.highlight +boolean/vim.shared._submodules.inspect +boolean/vim.shared._submodules.F +function/0/vim.shared.empty_dict +function/1/vim.shared._load_package +function/0/vim.shared.register_keystroke_callback +function/3/vim.shared.notify_once +function/3/vim.shared.notify +function/0/vim.shared.loop.getuid +function/0/vim.shared.loop.setuid +function/0/vim.shared.loop.getgid +function/0/vim.shared.loop.setgid +function/0/vim.shared.loop.getrusage +function/0/vim.shared.loop.guess_handle +function/0/vim.shared.loop.hrtime +function/0/vim.shared.loop.interface_addresses +function/0/vim.shared.loop.loadavg +function/0/vim.shared.loop.resident_set_memory +function/0/vim.shared.loop.set_process_title +function/0/vim.shared.loop.uptime +function/0/vim.shared.loop.version_string +function/0/vim.shared.loop.print_all_handles +function/0/vim.shared.loop.print_active_handles +function/0/vim.shared.loop.os_getenv +function/0/vim.shared.loop.os_setenv +function/0/vim.shared.loop.os_unsetenv +function/0/vim.shared.loop.os_gethostname +function/0/vim.shared.loop.if_indextoname +function/0/vim.shared.loop.if_indextoiid +function/0/vim.shared.loop.os_getppid +function/0/vim.shared.loop.os_getpid +function/0/vim.shared.loop.os_getpriority +function/0/vim.shared.loop.os_setpriority +function/0/vim.shared.loop.os_uname +function/0/vim.shared.loop.gettimeofday +function/0/vim.shared.loop.os_environ +function/0/vim.shared.loop.sleep +function/0/vim.shared.loop.new_thread +function/0/vim.shared.loop.loop_close +function/0/vim.shared.loop.run +function/0/vim.shared.loop.loop_mode +function/0/vim.shared.loop.loop_alive +function/0/vim.shared.loop.stop +function/0/vim.shared.loop.backend_fd +function/0/vim.shared.loop.backend_timeout +function/0/vim.shared.loop.now +function/0/vim.shared.loop.update_time +function/0/vim.shared.loop.walk +function/0/vim.shared.loop.loop_configure +function/0/vim.shared.loop.cancel +function/0/vim.shared.loop.req_get_type +function/0/vim.shared.loop.is_active +function/0/vim.shared.loop.is_closing +function/0/vim.shared.loop.ref +function/0/vim.shared.loop.unref +number/vim.shared.loop.constants.AI_V4MAPPED +number/vim.shared.loop.constants.AI_ALL +number/vim.shared.loop.constants.AI_NUMERICHOST +number/vim.shared.loop.constants.AI_PASSIVE +number/vim.shared.loop.constants.AI_NUMERICSERV +number/vim.shared.loop.constants.SIGHUP +number/vim.shared.loop.constants.SIGINT +number/vim.shared.loop.constants.SIGQUIT +number/vim.shared.loop.constants.SIGILL +number/vim.shared.loop.constants.SIGTRAP +number/vim.shared.loop.constants.SIGABRT +number/vim.shared.loop.constants.SIGIOT +number/vim.shared.loop.constants.SIGBUS +number/vim.shared.loop.constants.SIGFPE +number/vim.shared.loop.constants.SIGKILL +number/vim.shared.loop.constants.SIGUSR1 +number/vim.shared.loop.constants.SIGSEGV +number/vim.shared.loop.constants.SIGUSR2 +number/vim.shared.loop.constants.SIGPIPE +number/vim.shared.loop.constants.SIGALRM +number/vim.shared.loop.constants.SIGTERM +number/vim.shared.loop.constants.SIGCHLD +number/vim.shared.loop.constants.SIGSTKFLT +number/vim.shared.loop.constants.SIGCONT +number/vim.shared.loop.constants.SIGSTOP +number/vim.shared.loop.constants.SIGTSTP +number/vim.shared.loop.constants.SIGTTIN +number/vim.shared.loop.constants.SIGTTOU +number/vim.shared.loop.constants.SIGURG +number/vim.shared.loop.constants.SIGXCPU +number/vim.shared.loop.constants.SIGXFSZ +number/vim.shared.loop.constants.SIGVTALRM +number/vim.shared.loop.constants.SIGPROF +number/vim.shared.loop.constants.SIGWINCH +number/vim.shared.loop.constants.SIGIO +number/vim.shared.loop.constants.SIGPOLL +number/vim.shared.loop.constants.SIGPWR +number/vim.shared.loop.constants.SIGSYS +number/vim.shared.loop.constants.UDP_MMSG_FREE +number/vim.shared.loop.constants.UDP_RECVMMSG +number/vim.shared.loop.constants.UDP_MMSG_CHUNK +number/vim.shared.loop.constants.UDP_REUSEADDR +number/vim.shared.loop.constants.UDP_PARTIAL +number/vim.shared.loop.constants.UDP_IPV6ONLY +number/vim.shared.loop.constants.TCP_IPV6ONLY +number/vim.shared.loop.constants.O_RDONLY +number/vim.shared.loop.constants.O_WRONLY +number/vim.shared.loop.constants.O_RDWR +number/vim.shared.loop.constants.O_APPEND +number/vim.shared.loop.constants.O_CREAT +number/vim.shared.loop.constants.O_DSYNC +number/vim.shared.loop.constants.O_EXCL +number/vim.shared.loop.constants.O_NOCTTY +number/vim.shared.loop.constants.O_NONBLOCK +number/vim.shared.loop.constants.O_RSYNC +number/vim.shared.loop.constants.O_SYNC +number/vim.shared.loop.constants.O_TRUNC +number/vim.shared.loop.constants.SOCK_STREAM +number/vim.shared.loop.constants.SOCK_DGRAM +number/vim.shared.loop.constants.SOCK_SEQPACKET +number/vim.shared.loop.constants.SOCK_RAW +number/vim.shared.loop.constants.SOCK_RDM +number/vim.shared.loop.constants.AF_UNIX +number/vim.shared.loop.constants.AF_INET +number/vim.shared.loop.constants.AF_INET6 +number/vim.shared.loop.constants.AF_IPX +number/vim.shared.loop.constants.AF_NETLINK +number/vim.shared.loop.constants.AF_X25 +number/vim.shared.loop.constants.AF_AX25 +number/vim.shared.loop.constants.AF_ATMPVC +number/vim.shared.loop.constants.AF_APPLETALK +number/vim.shared.loop.constants.AF_PACKET +number/vim.shared.loop.constants.AI_ADDRCONFIG +function/0/vim.shared.loop.version +function/0/vim.shared.loop.metrics_idle_time +function/0/vim.shared.loop.translate_sys_error +function/0/vim.shared.loop.queue_work +function/0/vim.shared.loop.new_work +function/0/vim.shared.loop.thread_join +function/0/vim.shared.loop.thread_self +function/0/vim.shared.loop.thread_equal +function/0/vim.shared.loop.random +function/0/vim.shared.loop.new_tcp +function/0/vim.shared.loop.tcp_nodelay +function/0/vim.shared.loop.fs_close +function/0/vim.shared.loop.fs_open +function/0/vim.shared.loop.fs_read +function/0/vim.shared.loop.fs_unlink +function/0/vim.shared.loop.fs_write +function/0/vim.shared.loop.fs_mkdir +function/0/vim.shared.loop.fs_mkdtemp +function/0/vim.shared.loop.fs_mkstemp +function/0/vim.shared.loop.fs_rmdir +function/0/vim.shared.loop.fs_scandir +function/0/vim.shared.loop.fs_scandir_next +function/0/vim.shared.loop.fs_stat +function/0/vim.shared.loop.fs_fstat +function/0/vim.shared.loop.fs_lstat +function/0/vim.shared.loop.fs_rename +function/0/vim.shared.loop.fs_fsync +function/0/vim.shared.loop.fs_fdatasync +function/0/vim.shared.loop.fs_ftruncate +function/0/vim.shared.loop.fs_sendfile +function/0/vim.shared.loop.fs_chown +function/0/vim.shared.loop.fs_realpath +function/0/vim.shared.loop.fs_readlink +function/0/vim.shared.loop.fs_symlink +function/0/vim.shared.loop.fs_link +function/0/vim.shared.loop.fs_lutime +function/0/vim.shared.loop.fs_futime +function/0/vim.shared.loop.fs_utime +function/0/vim.shared.loop.fs_fchmod +function/0/vim.shared.loop.fs_chmod +function/0/vim.shared.loop.has_ref +function/0/vim.shared.loop.send_buffer_size +function/0/vim.shared.loop.recv_buffer_size +function/0/vim.shared.loop.fileno +function/0/vim.shared.loop.handle_get_type +function/0/vim.shared.loop.new_timer +function/0/vim.shared.loop.timer_start +function/0/vim.shared.loop.timer_stop +function/0/vim.shared.loop.timer_again +function/0/vim.shared.loop.timer_set_repeat +function/0/vim.shared.loop.timer_get_repeat +function/0/vim.shared.loop.timer_get_due_in +function/0/vim.shared.loop.new_prepare +function/0/vim.shared.loop.prepare_start +function/0/vim.shared.loop.prepare_stop +function/0/vim.shared.loop.new_check +function/0/vim.shared.loop.check_start +function/0/vim.shared.loop.check_stop +function/0/vim.shared.loop.new_idle +function/0/vim.shared.loop.idle_start +function/0/vim.shared.loop.idle_stop +function/0/vim.shared.loop.new_async +function/0/vim.shared.loop.async_send +function/0/vim.shared.loop.new_poll +function/0/vim.shared.loop.new_socket_poll +function/0/vim.shared.loop.poll_start +function/0/vim.shared.loop.poll_stop +function/0/vim.shared.loop.new_signal +function/0/vim.shared.loop.signal_start +function/0/vim.shared.loop.signal_start_oneshot +function/0/vim.shared.loop.signal_stop +function/0/vim.shared.loop.disable_stdio_inheritance +function/0/vim.shared.loop.spawn +function/0/vim.shared.loop.process_kill +function/0/vim.shared.loop.process_get_pid +function/0/vim.shared.loop.kill +function/0/vim.shared.loop.shutdown +function/0/vim.shared.loop.listen +function/0/vim.shared.loop.accept +function/0/vim.shared.loop.read_start +function/0/vim.shared.loop.read_stop +function/0/vim.shared.loop.write2 +function/0/vim.shared.loop.try_write +function/0/vim.shared.loop.try_write2 +function/0/vim.shared.loop.is_readable +function/0/vim.shared.loop.is_writable +function/0/vim.shared.loop.stream_set_blocking +function/0/vim.shared.loop.stream_get_write_queue_size +function/0/vim.shared.loop.close +function/0/vim.shared.loop.tcp_open +function/0/vim.shared.loop.write +function/0/vim.shared.loop.tcp_keepalive +function/0/vim.shared.loop.tcp_simultaneous_accepts +function/0/vim.shared.loop.tcp_bind +function/0/vim.shared.loop.tcp_getpeername +function/0/vim.shared.loop.tcp_getsockname +function/0/vim.shared.loop.tcp_connect +function/0/vim.shared.loop.tcp_write_queue_size +function/0/vim.shared.loop.tcp_close_reset +function/0/vim.shared.loop.socketpair +function/0/vim.shared.loop.new_pipe +function/0/vim.shared.loop.fs_access +function/0/vim.shared.loop.udp_try_send +function/0/vim.shared.loop.udp_recv_start +function/0/vim.shared.loop.udp_recv_stop +function/0/vim.shared.loop.udp_connect +function/0/vim.shared.loop.udp_getpeername +function/0/vim.shared.loop.new_fs_event +function/0/vim.shared.loop.fs_event_start +function/0/vim.shared.loop.fs_event_stop +function/0/vim.shared.loop.fs_event_getpath +function/0/vim.shared.loop.new_fs_poll +function/0/vim.shared.loop.fs_poll_start +function/0/vim.shared.loop.fs_poll_stop +function/0/vim.shared.loop.fs_poll_getpath +function/0/vim.shared.loop.pipe_open +function/0/vim.shared.loop.pipe_bind +function/0/vim.shared.loop.pipe_chmod +function/0/vim.shared.loop.pipe_connect +function/0/vim.shared.loop.pipe_getsockname +function/0/vim.shared.loop.pipe_getpeername +function/0/vim.shared.loop.pipe_pending_instances +function/0/vim.shared.loop.pipe_pending_count +function/0/vim.shared.loop.pipe_pending_type +function/0/vim.shared.loop.pipe +function/0/vim.shared.loop.new_tty +function/0/vim.shared.loop.tty_set_mode +function/0/vim.shared.loop.tty_reset_mode +function/0/vim.shared.loop.tty_get_winsize +function/0/vim.shared.loop.tty_set_vterm_state +function/0/vim.shared.loop.tty_get_vterm_state +function/0/vim.shared.loop.new_udp +function/0/vim.shared.loop.udp_get_send_queue_size +function/0/vim.shared.loop.udp_get_send_queue_count +function/0/vim.shared.loop.udp_open +function/0/vim.shared.loop.udp_bind +function/0/vim.shared.loop.udp_getsockname +function/0/vim.shared.loop.udp_set_membership +function/0/vim.shared.loop.udp_set_source_membership +function/0/vim.shared.loop.udp_set_multicast_loop +function/0/vim.shared.loop.udp_set_multicast_ttl +function/0/vim.shared.loop.udp_set_multicast_interface +function/0/vim.shared.loop.udp_set_broadcast +function/0/vim.shared.loop.udp_set_ttl +function/0/vim.shared.loop.udp_send +function/0/vim.shared.loop.fs_fchown +function/0/vim.shared.loop.fs_lchown +function/0/vim.shared.loop.fs_copyfile +function/0/vim.shared.loop.fs_opendir +function/0/vim.shared.loop.fs_readdir +function/0/vim.shared.loop.fs_closedir +function/0/vim.shared.loop.fs_statfs +function/0/vim.shared.loop.getaddrinfo +function/0/vim.shared.loop.getnameinfo +function/0/vim.shared.loop.chdir +function/0/vim.shared.loop.os_homedir +function/0/vim.shared.loop.os_tmpdir +function/0/vim.shared.loop.os_get_passwd +function/0/vim.shared.loop.cpu_info +function/0/vim.shared.loop.cwd +function/0/vim.shared.loop.exepath +function/0/vim.shared.loop.get_process_title +function/0/vim.shared.loop.get_constrained_memory +function/0/vim.shared.loop.get_total_memory +function/0/vim.shared.loop.get_free_memory +function/0/vim.shared.loop.getpid +function/2/vim.shared.defer_fn +function/2/vim.shared.deepcopy +function/5/vim.shared.region +function/2/vim.shared.paste +function/1/vim.shared.uri_from_fname +function/1/vim.shared.uri_to_fname +function/0/vim.shared.version +function/3/vim.shared.gsplit +function/1/vim.shared.funcref +function/0/vim.shared.fn.getchar +function/0/vim.shared.fn.nr2char +function/0/vim.shared.fn.maparg +function/0/vim.shared.fn.expand +function/0/vim.shared.fn.reg_recording +function/0/vim.shared.fn.reg_executing +function/0/vim.shared.fn.isdirectory +function/0/vim.shared.fn.getcmdtype +function/0/vim.shared.fn.pumvisible +function/0/vim.shared.fn.getcmdline +function/0/vim.shared.fn.getcmdpos +function/1/vim.shared._os_proc_children +function/1/vim.shared._os_proc_info +function/0/vim.shared.diff +function/1/vim.shared.tbl_islist +function/1/vim.shared.tbl_isempty +function/1/vim.shared.defaulttable +function/1/vim.shared.is_callable +function/1/vim.shared.validate +function/2/vim.shared.endswith +function/1/vim.shared.tbl_get +function/0/vim.shared.regex +function/0/vim.shared.str_utf_end +function/0/vim.shared.str_utf_start +function/2/vim.shared.deep_equal +function/0/vim.shared.str_utf_pos +function/1/vim.shared.tbl_keys +function/1/vim.shared.tbl_add_reverse_lookup +function/2/vim.shared.tbl_contains +function/1/vim.shared.tbl_extend +function/2/vim.shared.tbl_filter +function/2/vim.shared.tbl_map +function/1/vim.shared.tbl_values +string/vim.shared.inspect._DESCRIPTION +string/vim.shared.inspect._VERSION +function/2/vim.shared.inspect.inspect +string/vim.shared.inspect._LICENSE +string/vim.shared.inspect._URL +number/vim.shared.log.levels.INFO +number/vim.shared.log.levels.DEBUG +number/vim.shared.log.levels.TRACE +number/vim.shared.log.levels.WARN +number/vim.shared.log.levels.ERROR +number/vim.shared.log.levels.OFF +function/0/vim.shared._create_ts_parser +function/0/vim.shared._ts_add_language +function/0/vim.shared._ts_has_language +function/0/vim.shared._ts_remove_language +function/0/vim.shared._ts_inspect_language +function/0/vim.shared._ts_parse_query +function/0/vim.shared._ts_get_language_version +function/0/vim.shared._ts_get_minimum_language_version +function/0/vim.shared.stricmp +function/0/vim.shared.str_utfindex +function/0/vim.shared.str_byteindex +function/1/vim.shared.pesc +function/1/vim.shared.trim +function/3/vim.shared.list_slice +function/1/vim.shared.tbl_count +function/1/vim.shared.spairs +boolean/package.loaded.vim._meta +userdata/io.stdout +function/0/io.type +function/0/io.close +function/0/io.read +function/0/io.write +function/0/io.flush +function/0/io.lines +userdata/io.stderr +function/0/io.open +function/0/io.popen +function/0/io.tmpfile +function/0/io.input +function/0/io.output +userdata/io.stdin +function/1/luasnip.loaders.load_lazy_loaded +function/0/luasnip.loaders.cleanup +function/1/luasnip.loaders.reload_file +function/1/luasnip.loaders.edit_snippet_files +function/2/Comment.api.call +function/1/Comment.api.locked +number/Comment.api.toggle.cmode +number/Comment.api.comment.cmode +number/Comment.api.uncomment.cmode +boolean/luasnip.util._builtin_vars.builtin_ns.RELATIVE +boolean/luasnip.util._builtin_vars.builtin_ns.RANDOM +boolean/luasnip.util._builtin_vars.builtin_ns.BLOCK +boolean/luasnip.util._builtin_vars.builtin_ns.SELECT +boolean/luasnip.util._builtin_vars.builtin_ns.LS +boolean/luasnip.util._builtin_vars.builtin_ns.LINE +boolean/luasnip.util._builtin_vars.builtin_ns.CURRENT +boolean/luasnip.util._builtin_vars.builtin_ns.TM +boolean/luasnip.util._builtin_vars.builtin_ns.WORKSPACE +function/1/luasnip.util._builtin_vars.is_table +function/1/luasnip.util._builtin_vars.vars +function/1/luasnip.util._builtin_vars.init +number/cmp.matcher.WORD_BOUNDALY_ORDER_FACTOR +number/cmp.matcher.PREFIX_FACTOR +function/0/cmp.matcher.debug +function/5/cmp.matcher.find_match_region +function/3/cmp.matcher.fuzzy +number/cmp.matcher.NOT_FUZZY_FACTOR +function/3/cmp.matcher.match +function/0/package.loaded.cmp.config.default +function/0/luasnip.util.environ.fake +function/1/luasnip.util.environ.is_table +function/3/luasnip.util.environ.new +function/2/luasnip.util.environ.__index +function/3/luasnip.util.environ.override +function/2/luasnip.util.environ.env_namespace +function/1/luasnip.available +function/0/luasnip.expand_or_jump +function/1/luasnip.store_snippet_docstrings +function/1/luasnip.change_choice +function/0/luasnip.get_active_snip +function/2/luasnip.get_snippets +function/1/luasnip.exit_out_of_region +function/0/luasnip.unlink_current_if_deleted +function/1/luasnip.load_snippet_docstrings +function/0/luasnip.expand_repeat +function/1/luasnip.setup +function/0/luasnip.unlink_current +function/0/luasnip.expand_or_jumpable +function/2/luasnip.filetype_extend +function/1/luasnip.expand +function/2/luasnip.filetype_set +function/0/luasnip.cleanup +function/1/luasnip.refresh_notify +function/1/luasnip.jump_destination +function/0/luasnip.expandable +function/0/luasnip.setup_snip_env +function/0/luasnip.in_snippet +function/0/luasnip.get_snip_env +function/1/luasnip.get_id_snippet +function/3/luasnip.add_snippets +function/1/luasnip.clean_invalidated +function/0/luasnip.expand_or_locally_jumpable +function/1/luasnip.locally_jumpable +function/2/luasnip.snip_expand +function/2/luasnip.env_namespace +function/0/luasnip.get_snippet_filetypes +function/0/luasnip.choice_active +function/1/luasnip.jump +function/1/luasnip.jumpable +function/1/luasnip.set_choice +function/0/luasnip.expand_auto +function/0/luasnip.active_update_dependents +function/2/luasnip.lsp_expand +function/0/luasnip.get_current_choices +function/2/luasnip.util.util.lazy_table +function/0/luasnip.util.util.get_selection +function/0/luasnip.util.util.get_cursor_0ind +function/0/luasnip.util.util.buffer_comment_chars +function/0/luasnip.util.util.store_selection +function/0/luasnip.util.util.yes +function/1/luasnip.util.util.to_line_table +function/1/luasnip.util.util.find_outer_snippet +function/1/luasnip.util.util.redirect_filetypes +function/1/luasnip.util.util.id +function/1/luasnip.util.util.set_cursor_0ind +function/0/luasnip.util.util.get_snippet_filetypes +function/0/luasnip.util.util.get_current_line_to_cursor +function/2/luasnip.util.util.pos_sub +function/1/luasnip.util.util.pop_front +function/2/luasnip.util.util.dedent +function/3/luasnip.util.util.expand_tabs +function/1/luasnip.util.util.no_region_check_wrap +function/1/luasnip.util.util.reverse_lookup +function/0/luasnip.util.util.tab_width +function/2/luasnip.util.util.mark_pos_equal +function/0/luasnip.util.util.json_decode +function/0/luasnip.util.util.json_encode +function/1/luasnip.util.util.bytecol_to_utfcol +function/2/luasnip.util.util.indx_of +function/0/luasnip.util.util.nop +function/0/luasnip.util.util.no +function/2/luasnip.util.util.any_select +function/1/luasnip.util.util.key_sorted_pairs +function/1/luasnip.util.util.normal_move_on_insert +function/1/luasnip.util.util.insert_move_on +function/2/luasnip.util.util.multiline_equal +function/1/luasnip.util.util.deduplicate +function/2/luasnip.util.util.pos_add +function/2/luasnip.util.util.word_under_cursor +function/1/luasnip.util.util.line_chars_before +function/2/luasnip.util.util.string_wrap +function/1/luasnip.util.util.remove_n_before_cur +function/2/luasnip.util.util.indent +function/2/luasnip.util.util.pos_equal +function/2/luasnip.util.util.put +function/1/luasnip.util.util.to_string_table +function/1/luasnip.util.util.wrap_nodes +function/1/luasnip.util.util.move_to_mark +function/1/luasnip.config.setup +function/0/luasnip.config._setup +function/1/luasnip.config.set_config +function/1/vim.uri.uri_from_fname +function/1/vim.uri.uri_from_bufnr +function/1/vim.uri.uri_to_bufnr +function/1/vim.uri.uri_to_fname +function/2/which-key.register +function/1/which-key.setup +function/1/which-key.execute +function/0/which-key.load +function/0/which-key.reset +function/2/which-key.show_command +function/2/which-key.show +function/2/cmp.view.custom_entries_view.select_next_item +function/2/cmp.view.custom_entries_view.select_prev_item +number/cmp.view.custom_entries_view.ns +function/1/cmp.view.custom_entries_view.visible +function/1/cmp.view.custom_entries_view.is_direction_top_down +function/1/cmp.view.custom_entries_view.get_active_entry +function/1/cmp.view.custom_entries_view.get_entries +function/0/cmp.view.custom_entries_view.ready +function/1/cmp.view.custom_entries_view.abort +function/3/cmp.view.custom_entries_view._select +boolean/cmp.view.custom_entries_view._insert.pending +function/1/cmp.view.custom_entries_view.get_selected_entry +function/1/cmp.view.custom_entries_view.get_offset +function/1/cmp.view.custom_entries_view.close +function/3/cmp.view.custom_entries_view.open +function/1/cmp.view.custom_entries_view.draw +function/1/cmp.view.custom_entries_view.info +function/1/cmp.view.custom_entries_view.get_first_entry +function/1/cmp.view.custom_entries_view.on_change +function/0/cmp.view.custom_entries_view.new +function/3/which-key.tree.walk +function/4/which-key.tree.get +function/2/which-key.tree.path +function/2/which-key.tree.add +function/1/which-key.tree.new +function/0/os.execute +function/0/os.rename +function/0/os.tmpname +function/0/os.getenv +function/0/os.exit +function/0/os.clock +function/0/os.date +function/0/os.time +function/0/os.remove +function/0/os.setlocale +function/0/os.difftime +function/3/cmp_nvim_lsp.source.execute +function/3/cmp_nvim_lsp.source._get +function/3/cmp_nvim_lsp.source.complete +function/1/cmp_nvim_lsp.source.is_available +function/1/cmp_nvim_lsp.source.get_debug_name +function/4/cmp_nvim_lsp.source._request +function/1/cmp_nvim_lsp.source.get_position_encoding_kind +function/2/cmp_nvim_lsp.source.get_keyword_pattern +function/1/cmp_nvim_lsp.source.get_trigger_characters +function/3/cmp_nvim_lsp.source.resolve +function/1/cmp_nvim_lsp.source.new +number/vim.lsp._snippet.NodeType.TABSTOP +number/vim.lsp._snippet.NodeType.PLACEHOLDER +number/vim.lsp._snippet.NodeType.VARIABLE +number/vim.lsp._snippet.NodeType.CHOICE +number/vim.lsp._snippet.NodeType.TRANSFORM +number/vim.lsp._snippet.NodeType.FORMAT +number/vim.lsp._snippet.NodeType.TEXT +number/vim.lsp._snippet.NodeType.SNIPPET +function/1/vim.lsp._snippet.parse +function/1/which-key.util.error +function/1/which-key.util.parse_internal +function/1/which-key.util.is_empty +function/1/which-key.util.count +function/0/which-key.util.get_mode +function/1/which-key.util.warn +function/2/which-key.util.check_mode +function/1/which-key.util.t +function/1/which-key.util.parse_keys +function/2/which-key.keys.register +function/4/which-key.keys.process_motions +function/2/which-key.keys.is_hook +boolean/which-key.keys.hooked.n@ +boolean/which-key.keys.hooked.n^W +boolean/which-key.keys.hooked.n] +boolean/which-key.keys.hooked.n" +boolean/which-key.keys.hooked.n! +boolean/which-key.keys.hooked.nva +boolean/which-key.keys.hooked.n' +boolean/which-key.keys.hooked.n!a +boolean/which-key.keys.hooked.nya +boolean/which-key.keys.hooked.ng +boolean/which-key.keys.hooked.ny +boolean/which-key.keys.hooked.vg +boolean/which-key.keys.hooked.ng` +boolean/which-key.keys.hooked.n!i +boolean/which-key.keys.hooked.ng' +boolean/which-key.keys.hooked.nc +boolean/which-key.keys.hooked.ng~ +boolean/which-key.keys.hooked.vi +boolean/which-key.keys.hooked.v" +boolean/which-key.keys.hooked.ng~a +boolean/which-key.keys.hooked.i^R +boolean/which-key.keys.hooked.va +boolean/which-key.keys.hooked.ng~i +boolean/which-key.keys.hooked.v +boolean/which-key.keys.hooked.c^R +boolean/which-key.keys.hooked.n> +boolean/which-key.keys.hooked.nci +boolean/which-key.keys.hooked.nca +boolean/which-key.keys.hooked.ngua +boolean/which-key.keys.hooked.v[ +boolean/which-key.keys.hooked.nyi +boolean/which-key.keys.hooked.ngui +boolean/which-key.keys.hooked.n c +boolean/which-key.keys.hooked.v] +boolean/which-key.keys.hooked.nz +boolean/which-key.keys.hooked.n w +boolean/which-key.keys.hooked.n>i +boolean/which-key.keys.hooked.nzf +boolean/which-key.keys.hooked.n r +boolean/which-key.keys.hooked.nv +boolean/which-key.keys.hooked.nzfa +boolean/which-key.keys.hooked.ngUi +boolean/which-key.keys.hooked.ngUa +boolean/which-key.keys.hooked.nzfi +boolean/which-key.keys.hooked.ngU +boolean/which-key.keys.hooked.na +function/3/which-key.keys.hook_id +function/3/which-key.keys.is_hooked +function/3/which-key.keys.hook_del +function/4/which-key.keys.hook_add +function/5/which-key.keys.map +string/which-key.keys.mappings.n35.tree.root.prefix_n +string/which-key.keys.mappings.n35.tree.root.mapping.keys.keys +string/which-key.keys.mappings.n35.tree.root.mapping.prefix +boolean/which-key.keys.mappings.n35.tree.root.mapping.group +string/which-key.keys.mappings.n35.tree.root.prefix_i +string/which-key.keys.mappings.n35.mode +number/which-key.keys.mappings.n35.buf +string/which-key.keys.mappings.o.tree.root.prefix_n +string/which-key.keys.mappings.o.tree.root.mapping.keys.keys +string/which-key.keys.mappings.o.tree.root.mapping.prefix +boolean/which-key.keys.mappings.o.tree.root.mapping.group +string/which-key.keys.mappings.o.tree.root.children.^.prefix_n +string/which-key.keys.mappings.o.tree.root.children.^.mapping.keys.keys +string/which-key.keys.mappings.o.tree.root.children.^.mapping.keys.notation.1 +string/which-key.keys.mappings.o.tree.root.children.^.mapping.keys.internal.1 +boolean/which-key.keys.mappings.o.tree.root.children.^.mapping.preset +string/which-key.keys.mappings.o.tree.root.children.^.mapping.mode +string/which-key.keys.mappings.o.tree.root.children.^.mapping.label +boolean/which-key.keys.mappings.o.tree.root.children.^.mapping.opts.silent +string/which-key.keys.mappings.o.tree.root.children.^.mapping.opts.desc +boolean/which-key.keys.mappings.o.tree.root.children.^.mapping.opts.noremap +string/which-key.keys.mappings.o.tree.root.children.^.mapping.prefix +string/which-key.keys.mappings.o.tree.root.children.^.prefix_i +string/which-key.keys.mappings.o.tree.root.children.F.prefix_n +string/which-key.keys.mappings.o.tree.root.children.F.mapping.keys.keys +string/which-key.keys.mappings.o.tree.root.children.F.mapping.keys.notation.1 +string/which-key.keys.mappings.o.tree.root.children.F.mapping.keys.internal.1 +boolean/which-key.keys.mappings.o.tree.root.children.F.mapping.preset +string/which-key.keys.mappings.o.tree.root.children.F.mapping.mode +string/which-key.keys.mappings.o.tree.root.children.F.mapping.label +boolean/which-key.keys.mappings.o.tree.root.children.F.mapping.opts.silent +string/which-key.keys.mappings.o.tree.root.children.F.mapping.opts.desc +boolean/which-key.keys.mappings.o.tree.root.children.F.mapping.opts.noremap +string/which-key.keys.mappings.o.tree.root.children.F.mapping.prefix +string/which-key.keys.mappings.o.tree.root.children.F.prefix_i +string/which-key.keys.mappings.o.tree.root.children.j.prefix_n +string/which-key.keys.mappings.o.tree.root.children.j.mapping.keys.keys +string/which-key.keys.mappings.o.tree.root.children.j.mapping.keys.notation.1 +string/which-key.keys.mappings.o.tree.root.children.j.mapping.keys.internal.1 +boolean/which-key.keys.mappings.o.tree.root.children.j.mapping.preset +string/which-key.keys.mappings.o.tree.root.children.j.mapping.mode +string/which-key.keys.mappings.o.tree.root.children.j.mapping.label +boolean/which-key.keys.mappings.o.tree.root.children.j.mapping.opts.silent +string/which-key.keys.mappings.o.tree.root.children.j.mapping.opts.desc +boolean/which-key.keys.mappings.o.tree.root.children.j.mapping.opts.noremap +string/which-key.keys.mappings.o.tree.root.children.j.mapping.prefix +string/which-key.keys.mappings.o.tree.root.children.j.prefix_i +string/which-key.keys.mappings.o.tree.root.children.a.prefix_n +string/which-key.keys.mappings.o.tree.root.children.a.mapping.keys.keys +string/which-key.keys.mappings.o.tree.root.children.a.mapping.keys.notation.1 +string/which-key.keys.mappings.o.tree.root.children.a.mapping.keys.internal.1 +string/which-key.keys.mappings.o.tree.root.children.a.mapping.prefix +string/which-key.keys.mappings.o.tree.root.children.a.mapping.name +boolean/which-key.keys.mappings.o.tree.root.children.a.mapping.preset +boolean/which-key.keys.mappings.o.tree.root.children.a.mapping.group +string/which-key.keys.mappings.o.tree.root.children.a.mapping.label +string/which-key.keys.mappings.o.tree.root.children.a.mapping.mode +boolean/which-key.keys.mappings.o.tree.root.children.a.mapping.opts.silent +boolean/which-key.keys.mappings.o.tree.root.children.a.mapping.opts.noremap +string/which-key.keys.mappings.o.tree.root.children.a.children.).prefix_n +string/which-key.keys.mappings.o.tree.root.children.a.children.).mapping.keys.keys +string/which-key.keys.mappings.o.tree.root.children.a.children.).mapping.keys.notation.1 +string/which-key.keys.mappings.o.tree.root.children.a.children.).mapping.keys.notation.2 +string/which-key.keys.mappings.o.tree.root.children.a.children.).mapping.keys.internal.1 +string/which-key.keys.mappings.o.tree.root.children.a.children.).mapping.keys.internal.2 +boolean/which-key.keys.mappings.o.tree.root.children.a.children.).mapping.preset +string/which-key.keys.mappings.o.tree.root.children.a.children.).mapping.mode +string/which-key.keys.mappings.o.tree.root.children.a.children.).mapping.label +boolean/which-key.keys.mappings.o.tree.root.children.a.children.).mapping.opts.silent +string/which-key.keys.mappings.o.tree.root.children.a.children.).mapping.opts.desc +boolean/which-key.keys.mappings.o.tree.root.children.a.children.).mapping.opts.noremap +string/which-key.keys.mappings.o.tree.root.children.a.children.).mapping.prefix +string/which-key.keys.mappings.o.tree.root.children.a.children.).prefix_i +string/which-key.keys.mappings.o.tree.root.children.a.children.}.prefix_n +string/which-key.keys.mappings.o.tree.root.children.a.children.}.mapping.keys.keys +string/which-key.keys.mappings.o.tree.root.children.a.children.}.mapping.keys.notation.1 +string/which-key.keys.mappings.o.tree.root.children.a.children.}.mapping.keys.notation.2 +string/which-key.keys.mappings.o.tree.root.children.a.children.}.mapping.keys.internal.1 +string/which-key.keys.mappings.o.tree.root.children.a.children.}.mapping.keys.internal.2 +boolean/which-key.keys.mappings.o.tree.root.children.a.children.}.mapping.preset +string/which-key.keys.mappings.o.tree.root.children.a.children.}.mapping.mode +string/which-key.keys.mappings.o.tree.root.children.a.children.}.mapping.label +boolean/which-key.keys.mappings.o.tree.root.children.a.children.}.mapping.opts.silent +string/which-key.keys.mappings.o.tree.root.children.a.children.}.mapping.opts.desc +boolean/which-key.keys.mappings.o.tree.root.children.a.children.}.mapping.opts.noremap +string/which-key.keys.mappings.o.tree.root.children.a.children.}.mapping.prefix +string/which-key.keys.mappings.o.tree.root.children.a.children.}.prefix_i +string/which-key.keys.mappings.o.tree.root.children.a.children.<.prefix_n +string/which-key.keys.mappings.o.tree.root.children.a.children.<.mapping.keys.keys +string/which-key.keys.mappings.o.tree.root.children.a.children.<.mapping.keys.notation.1 +string/which-key.keys.mappings.o.tree.root.children.a.children.<.mapping.keys.notation.2 +string/which-key.keys.mappings.o.tree.root.children.a.children.<.mapping.keys.internal.1 +string/which-key.keys.mappings.o.tree.root.children.a.children.<.mapping.keys.internal.2 +boolean/which-key.keys.mappings.o.tree.root.children.a.children.<.mapping.preset +string/which-key.keys.mappings.o.tree.root.children.a.children.<.mapping.mode +string/which-key.keys.mappings.o.tree.root.children.a.children.<.mapping.label +boolean/which-key.keys.mappings.o.tree.root.children.a.children.<.mapping.opts.silent +string/which-key.keys.mappings.o.tree.root.children.a.children.<.mapping.opts.desc +boolean/which-key.keys.mappings.o.tree.root.children.a.children.<.mapping.opts.noremap +string/which-key.keys.mappings.o.tree.root.children.a.children.<.mapping.prefix +string/which-key.keys.mappings.o.tree.root.children.a.children.<.prefix_i +string/which-key.keys.mappings.o.tree.root.children.a.children.>.prefix_n +string/which-key.keys.mappings.o.tree.root.children.a.children.>.mapping.keys.keys +string/which-key.keys.mappings.o.tree.root.children.a.children.>.mapping.keys.notation.1 +string/which-key.keys.mappings.o.tree.root.children.a.children.>.mapping.keys.notation.2 +string/which-key.keys.mappings.o.tree.root.children.a.children.>.mapping.keys.internal.1 +string/which-key.keys.mappings.o.tree.root.children.a.children.>.mapping.keys.internal.2 +boolean/which-key.keys.mappings.o.tree.root.children.a.children.>.mapping.preset +string/which-key.keys.mappings.o.tree.root.children.a.children.>.mapping.mode +string/which-key.keys.mappings.o.tree.root.children.a.children.>.mapping.label +boolean/which-key.keys.mappings.o.tree.root.children.a.children.>.mapping.opts.silent +string/which-key.keys.mappings.o.tree.root.children.a.children.>.mapping.opts.desc +boolean/which-key.keys.mappings.o.tree.root.children.a.children.>.mapping.opts.noremap +string/which-key.keys.mappings.o.tree.root.children.a.children.>.mapping.prefix +string/which-key.keys.mappings.o.tree.root.children.a.children.>.prefix_i +string/which-key.keys.mappings.o.tree.root.children.a.children.b.prefix_n +string/which-key.keys.mappings.o.tree.root.children.a.children.b.mapping.keys.keys +string/which-key.keys.mappings.o.tree.root.children.a.children.b.mapping.keys.notation.1 +string/which-key.keys.mappings.o.tree.root.children.a.children.b.mapping.keys.notation.2 +string/which-key.keys.mappings.o.tree.root.children.a.children.b.mapping.keys.internal.1 +string/which-key.keys.mappings.o.tree.root.children.a.children.b.mapping.keys.internal.2 +boolean/which-key.keys.mappings.o.tree.root.children.a.children.b.mapping.preset +string/which-key.keys.mappings.o.tree.root.children.a.children.b.mapping.mode +string/which-key.keys.mappings.o.tree.root.children.a.children.b.mapping.label +boolean/which-key.keys.mappings.o.tree.root.children.a.children.b.mapping.opts.silent +string/which-key.keys.mappings.o.tree.root.children.a.children.b.mapping.opts.desc +boolean/which-key.keys.mappings.o.tree.root.children.a.children.b.mapping.opts.noremap +string/which-key.keys.mappings.o.tree.root.children.a.children.b.mapping.prefix +string/which-key.keys.mappings.o.tree.root.children.a.children.b.prefix_i +string/which-key.keys.mappings.o.tree.root.children.a.children.{.prefix_n +string/which-key.keys.mappings.o.tree.root.children.a.children.{.mapping.keys.keys +string/which-key.keys.mappings.o.tree.root.children.a.children.{.mapping.keys.notation.1 +string/which-key.keys.mappings.o.tree.root.children.a.children.{.mapping.keys.notation.2 +string/which-key.keys.mappings.o.tree.root.children.a.children.{.mapping.keys.internal.1 +string/which-key.keys.mappings.o.tree.root.children.a.children.{.mapping.keys.internal.2 +boolean/which-key.keys.mappings.o.tree.root.children.a.children.{.mapping.preset +string/which-key.keys.mappings.o.tree.root.children.a.children.{.mapping.mode +string/which-key.keys.mappings.o.tree.root.children.a.children.{.mapping.label +boolean/which-key.keys.mappings.o.tree.root.children.a.children.{.mapping.opts.silent +string/which-key.keys.mappings.o.tree.root.children.a.children.{.mapping.opts.desc +boolean/which-key.keys.mappings.o.tree.root.children.a.children.{.mapping.opts.noremap +string/which-key.keys.mappings.o.tree.root.children.a.children.{.mapping.prefix +string/which-key.keys.mappings.o.tree.root.children.a.children.{.prefix_i +string/which-key.keys.mappings.o.tree.root.children.a.children.s.prefix_n +string/which-key.keys.mappings.o.tree.root.children.a.children.s.mapping.keys.keys +string/which-key.keys.mappings.o.tree.root.children.a.children.s.mapping.keys.notation.1 +string/which-key.keys.mappings.o.tree.root.children.a.children.s.mapping.keys.notation.2 +string/which-key.keys.mappings.o.tree.root.children.a.children.s.mapping.keys.internal.1 +string/which-key.keys.mappings.o.tree.root.children.a.children.s.mapping.keys.internal.2 +boolean/which-key.keys.mappings.o.tree.root.children.a.children.s.mapping.preset +string/which-key.keys.mappings.o.tree.root.children.a.children.s.mapping.mode +string/which-key.keys.mappings.o.tree.root.children.a.children.s.mapping.label +boolean/which-key.keys.mappings.o.tree.root.children.a.children.s.mapping.opts.silent +string/which-key.keys.mappings.o.tree.root.children.a.children.s.mapping.opts.desc +boolean/which-key.keys.mappings.o.tree.root.children.a.children.s.mapping.opts.noremap +string/which-key.keys.mappings.o.tree.root.children.a.children.s.mapping.prefix +string/which-key.keys.mappings.o.tree.root.children.a.children.s.prefix_i +string/which-key.keys.mappings.o.tree.root.children.a.children.(.prefix_n +string/which-key.keys.mappings.o.tree.root.children.a.children.(.mapping.keys.keys +string/which-key.keys.mappings.o.tree.root.children.a.children.(.mapping.keys.notation.1 +string/which-key.keys.mappings.o.tree.root.children.a.children.(.mapping.keys.notation.2 +string/which-key.keys.mappings.o.tree.root.children.a.children.(.mapping.keys.internal.1 +string/which-key.keys.mappings.o.tree.root.children.a.children.(.mapping.keys.internal.2 +boolean/which-key.keys.mappings.o.tree.root.children.a.children.(.mapping.preset +string/which-key.keys.mappings.o.tree.root.children.a.children.(.mapping.mode +string/which-key.keys.mappings.o.tree.root.children.a.children.(.mapping.label +boolean/which-key.keys.mappings.o.tree.root.children.a.children.(.mapping.opts.silent +string/which-key.keys.mappings.o.tree.root.children.a.children.(.mapping.opts.desc +boolean/which-key.keys.mappings.o.tree.root.children.a.children.(.mapping.opts.noremap +string/which-key.keys.mappings.o.tree.root.children.a.children.(.mapping.prefix +string/which-key.keys.mappings.o.tree.root.children.a.children.(.prefix_i +string/which-key.keys.mappings.o.tree.root.children.a.children.t.prefix_n +string/which-key.keys.mappings.o.tree.root.children.a.children.t.mapping.keys.keys +string/which-key.keys.mappings.o.tree.root.children.a.children.t.mapping.keys.notation.1 +string/which-key.keys.mappings.o.tree.root.children.a.children.t.mapping.keys.notation.2 +string/which-key.keys.mappings.o.tree.root.children.a.children.t.mapping.keys.internal.1 +string/which-key.keys.mappings.o.tree.root.children.a.children.t.mapping.keys.internal.2 +boolean/which-key.keys.mappings.o.tree.root.children.a.children.t.mapping.preset +string/which-key.keys.mappings.o.tree.root.children.a.children.t.mapping.mode +string/which-key.keys.mappings.o.tree.root.children.a.children.t.mapping.label +boolean/which-key.keys.mappings.o.tree.root.children.a.children.t.mapping.opts.silent +string/which-key.keys.mappings.o.tree.root.children.a.children.t.mapping.opts.desc +boolean/which-key.keys.mappings.o.tree.root.children.a.children.t.mapping.opts.noremap +string/which-key.keys.mappings.o.tree.root.children.a.children.t.mapping.prefix +string/which-key.keys.mappings.o.tree.root.children.a.children.t.prefix_i +string/which-key.keys.mappings.o.tree.root.children.a.children.`.prefix_n +string/which-key.keys.mappings.o.tree.root.children.a.children.`.mapping.keys.keys +string/which-key.keys.mappings.o.tree.root.children.a.children.`.mapping.keys.notation.1 +string/which-key.keys.mappings.o.tree.root.children.a.children.`.mapping.keys.notation.2 +string/which-key.keys.mappings.o.tree.root.children.a.children.`.mapping.keys.internal.1 +string/which-key.keys.mappings.o.tree.root.children.a.children.`.mapping.keys.internal.2 +boolean/which-key.keys.mappings.o.tree.root.children.a.children.`.mapping.preset +string/which-key.keys.mappings.o.tree.root.children.a.children.`.mapping.mode +string/which-key.keys.mappings.o.tree.root.children.a.children.`.mapping.label +boolean/which-key.keys.mappings.o.tree.root.children.a.children.`.mapping.opts.silent +string/which-key.keys.mappings.o.tree.root.children.a.children.`.mapping.opts.desc +boolean/which-key.keys.mappings.o.tree.root.children.a.children.`.mapping.opts.noremap +string/which-key.keys.mappings.o.tree.root.children.a.children.`.mapping.prefix +string/which-key.keys.mappings.o.tree.root.children.a.children.`.prefix_i +string/which-key.keys.mappings.o.tree.root.children.a.children.B.prefix_n +string/which-key.keys.mappings.o.tree.root.children.a.children.B.mapping.keys.keys +string/which-key.keys.mappings.o.tree.root.children.a.children.B.mapping.keys.notation.1 +string/which-key.keys.mappings.o.tree.root.children.a.children.B.mapping.keys.notation.2 +string/which-key.keys.mappings.o.tree.root.children.a.children.B.mapping.keys.internal.1 +string/which-key.keys.mappings.o.tree.root.children.a.children.B.mapping.keys.internal.2 +boolean/which-key.keys.mappings.o.tree.root.children.a.children.B.mapping.preset +string/which-key.keys.mappings.o.tree.root.children.a.children.B.mapping.mode +string/which-key.keys.mappings.o.tree.root.children.a.children.B.mapping.label +boolean/which-key.keys.mappings.o.tree.root.children.a.children.B.mapping.opts.silent +string/which-key.keys.mappings.o.tree.root.children.a.children.B.mapping.opts.desc +boolean/which-key.keys.mappings.o.tree.root.children.a.children.B.mapping.opts.noremap +string/which-key.keys.mappings.o.tree.root.children.a.children.B.mapping.prefix +string/which-key.keys.mappings.o.tree.root.children.a.children.B.prefix_i +string/which-key.keys.mappings.o.tree.root.children.a.children.w.prefix_n +string/which-key.keys.mappings.o.tree.root.children.a.children.w.mapping.keys.keys +string/which-key.keys.mappings.o.tree.root.children.a.children.w.mapping.keys.notation.1 +string/which-key.keys.mappings.o.tree.root.children.a.children.w.mapping.keys.notation.2 +string/which-key.keys.mappings.o.tree.root.children.a.children.w.mapping.keys.internal.1 +string/which-key.keys.mappings.o.tree.root.children.a.children.w.mapping.keys.internal.2 +boolean/which-key.keys.mappings.o.tree.root.children.a.children.w.mapping.preset +string/which-key.keys.mappings.o.tree.root.children.a.children.w.mapping.mode +string/which-key.keys.mappings.o.tree.root.children.a.children.w.mapping.label +boolean/which-key.keys.mappings.o.tree.root.children.a.children.w.mapping.opts.silent +string/which-key.keys.mappings.o.tree.root.children.a.children.w.mapping.opts.desc +boolean/which-key.keys.mappings.o.tree.root.children.a.children.w.mapping.opts.noremap +string/which-key.keys.mappings.o.tree.root.children.a.children.w.mapping.prefix +string/which-key.keys.mappings.o.tree.root.children.a.children.w.prefix_i +string/which-key.keys.mappings.o.tree.root.children.a.children.".prefix_n +string/which-key.keys.mappings.o.tree.root.children.a.children.".mapping.keys.keys +string/which-key.keys.mappings.o.tree.root.children.a.children.".mapping.keys.notation.1 +string/which-key.keys.mappings.o.tree.root.children.a.children.".mapping.keys.notation.2 +string/which-key.keys.mappings.o.tree.root.children.a.children.".mapping.keys.internal.1 +string/which-key.keys.mappings.o.tree.root.children.a.children.".mapping.keys.internal.2 +boolean/which-key.keys.mappings.o.tree.root.children.a.children.".mapping.preset +string/which-key.keys.mappings.o.tree.root.children.a.children.".mapping.mode +string/which-key.keys.mappings.o.tree.root.children.a.children.".mapping.label +boolean/which-key.keys.mappings.o.tree.root.children.a.children.".mapping.opts.silent +string/which-key.keys.mappings.o.tree.root.children.a.children.".mapping.opts.desc +boolean/which-key.keys.mappings.o.tree.root.children.a.children.".mapping.opts.noremap +string/which-key.keys.mappings.o.tree.root.children.a.children.".mapping.prefix +string/which-key.keys.mappings.o.tree.root.children.a.children.".prefix_i +string/which-key.keys.mappings.o.tree.root.children.a.children.].prefix_n +string/which-key.keys.mappings.o.tree.root.children.a.children.].mapping.keys.keys +string/which-key.keys.mappings.o.tree.root.children.a.children.].mapping.keys.notation.1 +string/which-key.keys.mappings.o.tree.root.children.a.children.].mapping.keys.notation.2 +string/which-key.keys.mappings.o.tree.root.children.a.children.].mapping.keys.internal.1 +string/which-key.keys.mappings.o.tree.root.children.a.children.].mapping.keys.internal.2 +boolean/which-key.keys.mappings.o.tree.root.children.a.children.].mapping.preset +string/which-key.keys.mappings.o.tree.root.children.a.children.].mapping.mode +string/which-key.keys.mappings.o.tree.root.children.a.children.].mapping.label +boolean/which-key.keys.mappings.o.tree.root.children.a.children.].mapping.opts.silent +string/which-key.keys.mappings.o.tree.root.children.a.children.].mapping.opts.desc +boolean/which-key.keys.mappings.o.tree.root.children.a.children.].mapping.opts.noremap +string/which-key.keys.mappings.o.tree.root.children.a.children.].mapping.prefix +string/which-key.keys.mappings.o.tree.root.children.a.children.].prefix_i +string/which-key.keys.mappings.o.tree.root.children.a.children.'.prefix_n +string/which-key.keys.mappings.o.tree.root.children.a.children.'.mapping.keys.keys +string/which-key.keys.mappings.o.tree.root.children.a.children.'.mapping.keys.notation.1 +string/which-key.keys.mappings.o.tree.root.children.a.children.'.mapping.keys.notation.2 +string/which-key.keys.mappings.o.tree.root.children.a.children.'.mapping.keys.internal.1 +string/which-key.keys.mappings.o.tree.root.children.a.children.'.mapping.keys.internal.2 +boolean/which-key.keys.mappings.o.tree.root.children.a.children.'.mapping.preset +string/which-key.keys.mappings.o.tree.root.children.a.children.'.mapping.mode +string/which-key.keys.mappings.o.tree.root.children.a.children.'.mapping.label +boolean/which-key.keys.mappings.o.tree.root.children.a.children.'.mapping.opts.silent +string/which-key.keys.mappings.o.tree.root.children.a.children.'.mapping.opts.desc +boolean/which-key.keys.mappings.o.tree.root.children.a.children.'.mapping.opts.noremap +string/which-key.keys.mappings.o.tree.root.children.a.children.'.mapping.prefix +string/which-key.keys.mappings.o.tree.root.children.a.children.'.prefix_i +string/which-key.keys.mappings.o.tree.root.children.a.children.[.prefix_n +string/which-key.keys.mappings.o.tree.root.children.a.children.[.mapping.keys.keys +string/which-key.keys.mappings.o.tree.root.children.a.children.[.mapping.keys.notation.1 +string/which-key.keys.mappings.o.tree.root.children.a.children.[.mapping.keys.notation.2 +string/which-key.keys.mappings.o.tree.root.children.a.children.[.mapping.keys.internal.1 +string/which-key.keys.mappings.o.tree.root.children.a.children.[.mapping.keys.internal.2 +boolean/which-key.keys.mappings.o.tree.root.children.a.children.[.mapping.preset +string/which-key.keys.mappings.o.tree.root.children.a.children.[.mapping.mode +string/which-key.keys.mappings.o.tree.root.children.a.children.[.mapping.label +boolean/which-key.keys.mappings.o.tree.root.children.a.children.[.mapping.opts.silent +string/which-key.keys.mappings.o.tree.root.children.a.children.[.mapping.opts.desc +boolean/which-key.keys.mappings.o.tree.root.children.a.children.[.mapping.opts.noremap +string/which-key.keys.mappings.o.tree.root.children.a.children.[.mapping.prefix +string/which-key.keys.mappings.o.tree.root.children.a.children.[.prefix_i +string/which-key.keys.mappings.o.tree.root.children.a.children.W.prefix_n +string/which-key.keys.mappings.o.tree.root.children.a.children.W.mapping.keys.keys +string/which-key.keys.mappings.o.tree.root.children.a.children.W.mapping.keys.notation.1 +string/which-key.keys.mappings.o.tree.root.children.a.children.W.mapping.keys.notation.2 +string/which-key.keys.mappings.o.tree.root.children.a.children.W.mapping.keys.internal.1 +string/which-key.keys.mappings.o.tree.root.children.a.children.W.mapping.keys.internal.2 +boolean/which-key.keys.mappings.o.tree.root.children.a.children.W.mapping.preset +string/which-key.keys.mappings.o.tree.root.children.a.children.W.mapping.mode +string/which-key.keys.mappings.o.tree.root.children.a.children.W.mapping.label +boolean/which-key.keys.mappings.o.tree.root.children.a.children.W.mapping.opts.silent +string/which-key.keys.mappings.o.tree.root.children.a.children.W.mapping.opts.desc +boolean/which-key.keys.mappings.o.tree.root.children.a.children.W.mapping.opts.noremap +string/which-key.keys.mappings.o.tree.root.children.a.children.W.mapping.prefix +string/which-key.keys.mappings.o.tree.root.children.a.children.W.prefix_i +string/which-key.keys.mappings.o.tree.root.children.a.children.p.prefix_n +string/which-key.keys.mappings.o.tree.root.children.a.children.p.mapping.keys.keys +string/which-key.keys.mappings.o.tree.root.children.a.children.p.mapping.keys.notation.1 +string/which-key.keys.mappings.o.tree.root.children.a.children.p.mapping.keys.notation.2 +string/which-key.keys.mappings.o.tree.root.children.a.children.p.mapping.keys.internal.1 +string/which-key.keys.mappings.o.tree.root.children.a.children.p.mapping.keys.internal.2 +boolean/which-key.keys.mappings.o.tree.root.children.a.children.p.mapping.preset +string/which-key.keys.mappings.o.tree.root.children.a.children.p.mapping.mode +string/which-key.keys.mappings.o.tree.root.children.a.children.p.mapping.label +boolean/which-key.keys.mappings.o.tree.root.children.a.children.p.mapping.opts.silent +string/which-key.keys.mappings.o.tree.root.children.a.children.p.mapping.opts.desc +boolean/which-key.keys.mappings.o.tree.root.children.a.children.p.mapping.opts.noremap +string/which-key.keys.mappings.o.tree.root.children.a.children.p.mapping.prefix +string/which-key.keys.mappings.o.tree.root.children.a.children.p.prefix_i +string/which-key.keys.mappings.o.tree.root.children.a.prefix_i +string/which-key.keys.mappings.o.tree.root.children.}.prefix_n +string/which-key.keys.mappings.o.tree.root.children.}.mapping.keys.keys +string/which-key.keys.mappings.o.tree.root.children.}.mapping.keys.notation.1 +string/which-key.keys.mappings.o.tree.root.children.}.mapping.keys.internal.1 +boolean/which-key.keys.mappings.o.tree.root.children.}.mapping.preset +string/which-key.keys.mappings.o.tree.root.children.}.mapping.mode +string/which-key.keys.mappings.o.tree.root.children.}.mapping.label +boolean/which-key.keys.mappings.o.tree.root.children.}.mapping.opts.silent +string/which-key.keys.mappings.o.tree.root.children.}.mapping.opts.desc +boolean/which-key.keys.mappings.o.tree.root.children.}.mapping.opts.noremap +string/which-key.keys.mappings.o.tree.root.children.}.mapping.prefix +string/which-key.keys.mappings.o.tree.root.children.}.prefix_i +string/which-key.keys.mappings.o.tree.root.children.i.prefix_n +string/which-key.keys.mappings.o.tree.root.children.i.mapping.keys.keys +string/which-key.keys.mappings.o.tree.root.children.i.mapping.keys.notation.1 +string/which-key.keys.mappings.o.tree.root.children.i.mapping.keys.internal.1 +string/which-key.keys.mappings.o.tree.root.children.i.mapping.prefix +string/which-key.keys.mappings.o.tree.root.children.i.mapping.name +boolean/which-key.keys.mappings.o.tree.root.children.i.mapping.preset +boolean/which-key.keys.mappings.o.tree.root.children.i.mapping.group +string/which-key.keys.mappings.o.tree.root.children.i.mapping.label +string/which-key.keys.mappings.o.tree.root.children.i.mapping.mode +boolean/which-key.keys.mappings.o.tree.root.children.i.mapping.opts.silent +boolean/which-key.keys.mappings.o.tree.root.children.i.mapping.opts.noremap +string/which-key.keys.mappings.o.tree.root.children.i.children.).prefix_n +string/which-key.keys.mappings.o.tree.root.children.i.children.).mapping.keys.keys +string/which-key.keys.mappings.o.tree.root.children.i.children.).mapping.keys.notation.1 +string/which-key.keys.mappings.o.tree.root.children.i.children.).mapping.keys.notation.2 +string/which-key.keys.mappings.o.tree.root.children.i.children.).mapping.keys.internal.1 +string/which-key.keys.mappings.o.tree.root.children.i.children.).mapping.keys.internal.2 +boolean/which-key.keys.mappings.o.tree.root.children.i.children.).mapping.preset +string/which-key.keys.mappings.o.tree.root.children.i.children.).mapping.mode +string/which-key.keys.mappings.o.tree.root.children.i.children.).mapping.label +boolean/which-key.keys.mappings.o.tree.root.children.i.children.).mapping.opts.silent +string/which-key.keys.mappings.o.tree.root.children.i.children.).mapping.opts.desc +boolean/which-key.keys.mappings.o.tree.root.children.i.children.).mapping.opts.noremap +string/which-key.keys.mappings.o.tree.root.children.i.children.).mapping.prefix +string/which-key.keys.mappings.o.tree.root.children.i.children.).prefix_i +string/which-key.keys.mappings.o.tree.root.children.i.children.}.prefix_n +string/which-key.keys.mappings.o.tree.root.children.i.children.}.mapping.keys.keys +string/which-key.keys.mappings.o.tree.root.children.i.children.}.mapping.keys.notation.1 +string/which-key.keys.mappings.o.tree.root.children.i.children.}.mapping.keys.notation.2 +string/which-key.keys.mappings.o.tree.root.children.i.children.}.mapping.keys.internal.1 +string/which-key.keys.mappings.o.tree.root.children.i.children.}.mapping.keys.internal.2 +boolean/which-key.keys.mappings.o.tree.root.children.i.children.}.mapping.preset +string/which-key.keys.mappings.o.tree.root.children.i.children.}.mapping.mode +string/which-key.keys.mappings.o.tree.root.children.i.children.}.mapping.label +boolean/which-key.keys.mappings.o.tree.root.children.i.children.}.mapping.opts.silent +string/which-key.keys.mappings.o.tree.root.children.i.children.}.mapping.opts.desc +boolean/which-key.keys.mappings.o.tree.root.children.i.children.}.mapping.opts.noremap +string/which-key.keys.mappings.o.tree.root.children.i.children.}.mapping.prefix +string/which-key.keys.mappings.o.tree.root.children.i.children.}.prefix_i +string/which-key.keys.mappings.o.tree.root.children.i.children.<.prefix_n +string/which-key.keys.mappings.o.tree.root.children.i.children.<.mapping.keys.keys +string/which-key.keys.mappings.o.tree.root.children.i.children.<.mapping.keys.notation.1 +string/which-key.keys.mappings.o.tree.root.children.i.children.<.mapping.keys.notation.2 +string/which-key.keys.mappings.o.tree.root.children.i.children.<.mapping.keys.internal.1 +string/which-key.keys.mappings.o.tree.root.children.i.children.<.mapping.keys.internal.2 +boolean/which-key.keys.mappings.o.tree.root.children.i.children.<.mapping.preset +string/which-key.keys.mappings.o.tree.root.children.i.children.<.mapping.mode +string/which-key.keys.mappings.o.tree.root.children.i.children.<.mapping.label +boolean/which-key.keys.mappings.o.tree.root.children.i.children.<.mapping.opts.silent +string/which-key.keys.mappings.o.tree.root.children.i.children.<.mapping.opts.desc +boolean/which-key.keys.mappings.o.tree.root.children.i.children.<.mapping.opts.noremap +string/which-key.keys.mappings.o.tree.root.children.i.children.<.mapping.prefix +string/which-key.keys.mappings.o.tree.root.children.i.children.<.prefix_i +string/which-key.keys.mappings.o.tree.root.children.i.children.>.prefix_n +string/which-key.keys.mappings.o.tree.root.children.i.children.>.mapping.keys.keys +string/which-key.keys.mappings.o.tree.root.children.i.children.>.mapping.keys.notation.1 +string/which-key.keys.mappings.o.tree.root.children.i.children.>.mapping.keys.notation.2 +string/which-key.keys.mappings.o.tree.root.children.i.children.>.mapping.keys.internal.1 +string/which-key.keys.mappings.o.tree.root.children.i.children.>.mapping.keys.internal.2 +boolean/which-key.keys.mappings.o.tree.root.children.i.children.>.mapping.preset +string/which-key.keys.mappings.o.tree.root.children.i.children.>.mapping.mode +string/which-key.keys.mappings.o.tree.root.children.i.children.>.mapping.label +boolean/which-key.keys.mappings.o.tree.root.children.i.children.>.mapping.opts.silent +string/which-key.keys.mappings.o.tree.root.children.i.children.>.mapping.opts.desc +boolean/which-key.keys.mappings.o.tree.root.children.i.children.>.mapping.opts.noremap +string/which-key.keys.mappings.o.tree.root.children.i.children.>.mapping.prefix +string/which-key.keys.mappings.o.tree.root.children.i.children.>.prefix_i +string/which-key.keys.mappings.o.tree.root.children.i.children.b.prefix_n +string/which-key.keys.mappings.o.tree.root.children.i.children.b.mapping.keys.keys +string/which-key.keys.mappings.o.tree.root.children.i.children.b.mapping.keys.notation.1 +string/which-key.keys.mappings.o.tree.root.children.i.children.b.mapping.keys.notation.2 +string/which-key.keys.mappings.o.tree.root.children.i.children.b.mapping.keys.internal.1 +string/which-key.keys.mappings.o.tree.root.children.i.children.b.mapping.keys.internal.2 +boolean/which-key.keys.mappings.o.tree.root.children.i.children.b.mapping.preset +string/which-key.keys.mappings.o.tree.root.children.i.children.b.mapping.mode +string/which-key.keys.mappings.o.tree.root.children.i.children.b.mapping.label +boolean/which-key.keys.mappings.o.tree.root.children.i.children.b.mapping.opts.silent +string/which-key.keys.mappings.o.tree.root.children.i.children.b.mapping.opts.desc +boolean/which-key.keys.mappings.o.tree.root.children.i.children.b.mapping.opts.noremap +string/which-key.keys.mappings.o.tree.root.children.i.children.b.mapping.prefix +string/which-key.keys.mappings.o.tree.root.children.i.children.b.prefix_i +string/which-key.keys.mappings.o.tree.root.children.i.children.{.prefix_n +string/which-key.keys.mappings.o.tree.root.children.i.children.{.mapping.keys.keys +string/which-key.keys.mappings.o.tree.root.children.i.children.{.mapping.keys.notation.1 +string/which-key.keys.mappings.o.tree.root.children.i.children.{.mapping.keys.notation.2 +string/which-key.keys.mappings.o.tree.root.children.i.children.{.mapping.keys.internal.1 +string/which-key.keys.mappings.o.tree.root.children.i.children.{.mapping.keys.internal.2 +boolean/which-key.keys.mappings.o.tree.root.children.i.children.{.mapping.preset +string/which-key.keys.mappings.o.tree.root.children.i.children.{.mapping.mode +string/which-key.keys.mappings.o.tree.root.children.i.children.{.mapping.label +boolean/which-key.keys.mappings.o.tree.root.children.i.children.{.mapping.opts.silent +string/which-key.keys.mappings.o.tree.root.children.i.children.{.mapping.opts.desc +boolean/which-key.keys.mappings.o.tree.root.children.i.children.{.mapping.opts.noremap +string/which-key.keys.mappings.o.tree.root.children.i.children.{.mapping.prefix +string/which-key.keys.mappings.o.tree.root.children.i.children.{.prefix_i +string/which-key.keys.mappings.o.tree.root.children.i.children.s.prefix_n +string/which-key.keys.mappings.o.tree.root.children.i.children.s.mapping.keys.keys +string/which-key.keys.mappings.o.tree.root.children.i.children.s.mapping.keys.notation.1 +string/which-key.keys.mappings.o.tree.root.children.i.children.s.mapping.keys.notation.2 +string/which-key.keys.mappings.o.tree.root.children.i.children.s.mapping.keys.internal.1 +string/which-key.keys.mappings.o.tree.root.children.i.children.s.mapping.keys.internal.2 +boolean/which-key.keys.mappings.o.tree.root.children.i.children.s.mapping.preset +string/which-key.keys.mappings.o.tree.root.children.i.children.s.mapping.mode +string/which-key.keys.mappings.o.tree.root.children.i.children.s.mapping.label +boolean/which-key.keys.mappings.o.tree.root.children.i.children.s.mapping.opts.silent +string/which-key.keys.mappings.o.tree.root.children.i.children.s.mapping.opts.desc +boolean/which-key.keys.mappings.o.tree.root.children.i.children.s.mapping.opts.noremap +string/which-key.keys.mappings.o.tree.root.children.i.children.s.mapping.prefix +string/which-key.keys.mappings.o.tree.root.children.i.children.s.prefix_i +string/which-key.keys.mappings.o.tree.root.children.i.children.(.prefix_n +string/which-key.keys.mappings.o.tree.root.children.i.children.(.mapping.keys.keys +string/which-key.keys.mappings.o.tree.root.children.i.children.(.mapping.keys.notation.1 +string/which-key.keys.mappings.o.tree.root.children.i.children.(.mapping.keys.notation.2 +string/which-key.keys.mappings.o.tree.root.children.i.children.(.mapping.keys.internal.1 +string/which-key.keys.mappings.o.tree.root.children.i.children.(.mapping.keys.internal.2 +boolean/which-key.keys.mappings.o.tree.root.children.i.children.(.mapping.preset +string/which-key.keys.mappings.o.tree.root.children.i.children.(.mapping.mode +string/which-key.keys.mappings.o.tree.root.children.i.children.(.mapping.label +boolean/which-key.keys.mappings.o.tree.root.children.i.children.(.mapping.opts.silent +string/which-key.keys.mappings.o.tree.root.children.i.children.(.mapping.opts.desc +boolean/which-key.keys.mappings.o.tree.root.children.i.children.(.mapping.opts.noremap +string/which-key.keys.mappings.o.tree.root.children.i.children.(.mapping.prefix +string/which-key.keys.mappings.o.tree.root.children.i.children.(.prefix_i +string/which-key.keys.mappings.o.tree.root.children.i.children.t.prefix_n +string/which-key.keys.mappings.o.tree.root.children.i.children.t.mapping.keys.keys +string/which-key.keys.mappings.o.tree.root.children.i.children.t.mapping.keys.notation.1 +string/which-key.keys.mappings.o.tree.root.children.i.children.t.mapping.keys.notation.2 +string/which-key.keys.mappings.o.tree.root.children.i.children.t.mapping.keys.internal.1 +string/which-key.keys.mappings.o.tree.root.children.i.children.t.mapping.keys.internal.2 +boolean/which-key.keys.mappings.o.tree.root.children.i.children.t.mapping.preset +string/which-key.keys.mappings.o.tree.root.children.i.children.t.mapping.mode +string/which-key.keys.mappings.o.tree.root.children.i.children.t.mapping.label +boolean/which-key.keys.mappings.o.tree.root.children.i.children.t.mapping.opts.silent +string/which-key.keys.mappings.o.tree.root.children.i.children.t.mapping.opts.desc +boolean/which-key.keys.mappings.o.tree.root.children.i.children.t.mapping.opts.noremap +string/which-key.keys.mappings.o.tree.root.children.i.children.t.mapping.prefix +string/which-key.keys.mappings.o.tree.root.children.i.children.t.prefix_i +string/which-key.keys.mappings.o.tree.root.children.i.children.`.prefix_n +string/which-key.keys.mappings.o.tree.root.children.i.children.`.mapping.keys.keys +string/which-key.keys.mappings.o.tree.root.children.i.children.`.mapping.keys.notation.1 +string/which-key.keys.mappings.o.tree.root.children.i.children.`.mapping.keys.notation.2 +string/which-key.keys.mappings.o.tree.root.children.i.children.`.mapping.keys.internal.1 +string/which-key.keys.mappings.o.tree.root.children.i.children.`.mapping.keys.internal.2 +boolean/which-key.keys.mappings.o.tree.root.children.i.children.`.mapping.preset +string/which-key.keys.mappings.o.tree.root.children.i.children.`.mapping.mode +string/which-key.keys.mappings.o.tree.root.children.i.children.`.mapping.label +boolean/which-key.keys.mappings.o.tree.root.children.i.children.`.mapping.opts.silent +string/which-key.keys.mappings.o.tree.root.children.i.children.`.mapping.opts.desc +boolean/which-key.keys.mappings.o.tree.root.children.i.children.`.mapping.opts.noremap +string/which-key.keys.mappings.o.tree.root.children.i.children.`.mapping.prefix +string/which-key.keys.mappings.o.tree.root.children.i.children.`.prefix_i +string/which-key.keys.mappings.o.tree.root.children.i.children.W.prefix_n +string/which-key.keys.mappings.o.tree.root.children.i.children.W.mapping.keys.keys +string/which-key.keys.mappings.o.tree.root.children.i.children.W.mapping.keys.notation.1 +string/which-key.keys.mappings.o.tree.root.children.i.children.W.mapping.keys.notation.2 +string/which-key.keys.mappings.o.tree.root.children.i.children.W.mapping.keys.internal.1 +string/which-key.keys.mappings.o.tree.root.children.i.children.W.mapping.keys.internal.2 +boolean/which-key.keys.mappings.o.tree.root.children.i.children.W.mapping.preset +string/which-key.keys.mappings.o.tree.root.children.i.children.W.mapping.mode +string/which-key.keys.mappings.o.tree.root.children.i.children.W.mapping.label +boolean/which-key.keys.mappings.o.tree.root.children.i.children.W.mapping.opts.silent +string/which-key.keys.mappings.o.tree.root.children.i.children.W.mapping.opts.desc +boolean/which-key.keys.mappings.o.tree.root.children.i.children.W.mapping.opts.noremap +string/which-key.keys.mappings.o.tree.root.children.i.children.W.mapping.prefix +string/which-key.keys.mappings.o.tree.root.children.i.children.W.prefix_i +string/which-key.keys.mappings.o.tree.root.children.i.children.w.prefix_n +string/which-key.keys.mappings.o.tree.root.children.i.children.w.mapping.keys.keys +string/which-key.keys.mappings.o.tree.root.children.i.children.w.mapping.keys.notation.1 +string/which-key.keys.mappings.o.tree.root.children.i.children.w.mapping.keys.notation.2 +string/which-key.keys.mappings.o.tree.root.children.i.children.w.mapping.keys.internal.1 +string/which-key.keys.mappings.o.tree.root.children.i.children.w.mapping.keys.internal.2 +boolean/which-key.keys.mappings.o.tree.root.children.i.children.w.mapping.preset +string/which-key.keys.mappings.o.tree.root.children.i.children.w.mapping.mode +string/which-key.keys.mappings.o.tree.root.children.i.children.w.mapping.label +boolean/which-key.keys.mappings.o.tree.root.children.i.children.w.mapping.opts.silent +string/which-key.keys.mappings.o.tree.root.children.i.children.w.mapping.opts.desc +boolean/which-key.keys.mappings.o.tree.root.children.i.children.w.mapping.opts.noremap +string/which-key.keys.mappings.o.tree.root.children.i.children.w.mapping.prefix +string/which-key.keys.mappings.o.tree.root.children.i.children.w.prefix_i +string/which-key.keys.mappings.o.tree.root.children.i.children.".prefix_n +string/which-key.keys.mappings.o.tree.root.children.i.children.".mapping.keys.keys +string/which-key.keys.mappings.o.tree.root.children.i.children.".mapping.keys.notation.1 +string/which-key.keys.mappings.o.tree.root.children.i.children.".mapping.keys.notation.2 +string/which-key.keys.mappings.o.tree.root.children.i.children.".mapping.keys.internal.1 +string/which-key.keys.mappings.o.tree.root.children.i.children.".mapping.keys.internal.2 +boolean/which-key.keys.mappings.o.tree.root.children.i.children.".mapping.preset +string/which-key.keys.mappings.o.tree.root.children.i.children.".mapping.mode +string/which-key.keys.mappings.o.tree.root.children.i.children.".mapping.label +boolean/which-key.keys.mappings.o.tree.root.children.i.children.".mapping.opts.silent +string/which-key.keys.mappings.o.tree.root.children.i.children.".mapping.opts.desc +boolean/which-key.keys.mappings.o.tree.root.children.i.children.".mapping.opts.noremap +string/which-key.keys.mappings.o.tree.root.children.i.children.".mapping.prefix +string/which-key.keys.mappings.o.tree.root.children.i.children.".prefix_i +string/which-key.keys.mappings.o.tree.root.children.i.children.].prefix_n +string/which-key.keys.mappings.o.tree.root.children.i.children.].mapping.keys.keys +string/which-key.keys.mappings.o.tree.root.children.i.children.].mapping.keys.notation.1 +string/which-key.keys.mappings.o.tree.root.children.i.children.].mapping.keys.notation.2 +string/which-key.keys.mappings.o.tree.root.children.i.children.].mapping.keys.internal.1 +string/which-key.keys.mappings.o.tree.root.children.i.children.].mapping.keys.internal.2 +boolean/which-key.keys.mappings.o.tree.root.children.i.children.].mapping.preset +string/which-key.keys.mappings.o.tree.root.children.i.children.].mapping.mode +string/which-key.keys.mappings.o.tree.root.children.i.children.].mapping.label +boolean/which-key.keys.mappings.o.tree.root.children.i.children.].mapping.opts.silent +string/which-key.keys.mappings.o.tree.root.children.i.children.].mapping.opts.desc +boolean/which-key.keys.mappings.o.tree.root.children.i.children.].mapping.opts.noremap +string/which-key.keys.mappings.o.tree.root.children.i.children.].mapping.prefix +string/which-key.keys.mappings.o.tree.root.children.i.children.].prefix_i +string/which-key.keys.mappings.o.tree.root.children.i.children.'.prefix_n +string/which-key.keys.mappings.o.tree.root.children.i.children.'.mapping.keys.keys +string/which-key.keys.mappings.o.tree.root.children.i.children.'.mapping.keys.notation.1 +string/which-key.keys.mappings.o.tree.root.children.i.children.'.mapping.keys.notation.2 +string/which-key.keys.mappings.o.tree.root.children.i.children.'.mapping.keys.internal.1 +string/which-key.keys.mappings.o.tree.root.children.i.children.'.mapping.keys.internal.2 +boolean/which-key.keys.mappings.o.tree.root.children.i.children.'.mapping.preset +string/which-key.keys.mappings.o.tree.root.children.i.children.'.mapping.mode +string/which-key.keys.mappings.o.tree.root.children.i.children.'.mapping.label +boolean/which-key.keys.mappings.o.tree.root.children.i.children.'.mapping.opts.silent +string/which-key.keys.mappings.o.tree.root.children.i.children.'.mapping.opts.desc +boolean/which-key.keys.mappings.o.tree.root.children.i.children.'.mapping.opts.noremap +string/which-key.keys.mappings.o.tree.root.children.i.children.'.mapping.prefix +string/which-key.keys.mappings.o.tree.root.children.i.children.'.prefix_i +string/which-key.keys.mappings.o.tree.root.children.i.children.[.prefix_n +string/which-key.keys.mappings.o.tree.root.children.i.children.[.mapping.keys.keys +string/which-key.keys.mappings.o.tree.root.children.i.children.[.mapping.keys.notation.1 +string/which-key.keys.mappings.o.tree.root.children.i.children.[.mapping.keys.notation.2 +string/which-key.keys.mappings.o.tree.root.children.i.children.[.mapping.keys.internal.1 +string/which-key.keys.mappings.o.tree.root.children.i.children.[.mapping.keys.internal.2 +boolean/which-key.keys.mappings.o.tree.root.children.i.children.[.mapping.preset +string/which-key.keys.mappings.o.tree.root.children.i.children.[.mapping.mode +string/which-key.keys.mappings.o.tree.root.children.i.children.[.mapping.label +boolean/which-key.keys.mappings.o.tree.root.children.i.children.[.mapping.opts.silent +string/which-key.keys.mappings.o.tree.root.children.i.children.[.mapping.opts.desc +boolean/which-key.keys.mappings.o.tree.root.children.i.children.[.mapping.opts.noremap +string/which-key.keys.mappings.o.tree.root.children.i.children.[.mapping.prefix +string/which-key.keys.mappings.o.tree.root.children.i.children.[.prefix_i +string/which-key.keys.mappings.o.tree.root.children.i.children.B.prefix_n +string/which-key.keys.mappings.o.tree.root.children.i.children.B.mapping.keys.keys +string/which-key.keys.mappings.o.tree.root.children.i.children.B.mapping.keys.notation.1 +string/which-key.keys.mappings.o.tree.root.children.i.children.B.mapping.keys.notation.2 +string/which-key.keys.mappings.o.tree.root.children.i.children.B.mapping.keys.internal.1 +string/which-key.keys.mappings.o.tree.root.children.i.children.B.mapping.keys.internal.2 +boolean/which-key.keys.mappings.o.tree.root.children.i.children.B.mapping.preset +string/which-key.keys.mappings.o.tree.root.children.i.children.B.mapping.mode +string/which-key.keys.mappings.o.tree.root.children.i.children.B.mapping.label +boolean/which-key.keys.mappings.o.tree.root.children.i.children.B.mapping.opts.silent +string/which-key.keys.mappings.o.tree.root.children.i.children.B.mapping.opts.desc +boolean/which-key.keys.mappings.o.tree.root.children.i.children.B.mapping.opts.noremap +string/which-key.keys.mappings.o.tree.root.children.i.children.B.mapping.prefix +string/which-key.keys.mappings.o.tree.root.children.i.children.B.prefix_i +string/which-key.keys.mappings.o.tree.root.children.i.children.p.prefix_n +string/which-key.keys.mappings.o.tree.root.children.i.children.p.mapping.keys.keys +string/which-key.keys.mappings.o.tree.root.children.i.children.p.mapping.keys.notation.1 +string/which-key.keys.mappings.o.tree.root.children.i.children.p.mapping.keys.notation.2 +string/which-key.keys.mappings.o.tree.root.children.i.children.p.mapping.keys.internal.1 +string/which-key.keys.mappings.o.tree.root.children.i.children.p.mapping.keys.internal.2 +boolean/which-key.keys.mappings.o.tree.root.children.i.children.p.mapping.preset +string/which-key.keys.mappings.o.tree.root.children.i.children.p.mapping.mode +string/which-key.keys.mappings.o.tree.root.children.i.children.p.mapping.label +boolean/which-key.keys.mappings.o.tree.root.children.i.children.p.mapping.opts.silent +string/which-key.keys.mappings.o.tree.root.children.i.children.p.mapping.opts.desc +boolean/which-key.keys.mappings.o.tree.root.children.i.children.p.mapping.opts.noremap +string/which-key.keys.mappings.o.tree.root.children.i.children.p.mapping.prefix +string/which-key.keys.mappings.o.tree.root.children.i.children.p.prefix_i +string/which-key.keys.mappings.o.tree.root.children.i.prefix_i +string/which-key.keys.mappings.o.tree.root.children.b.prefix_n +string/which-key.keys.mappings.o.tree.root.children.b.mapping.keys.keys +string/which-key.keys.mappings.o.tree.root.children.b.mapping.keys.notation.1 +string/which-key.keys.mappings.o.tree.root.children.b.mapping.keys.internal.1 +boolean/which-key.keys.mappings.o.tree.root.children.b.mapping.preset +string/which-key.keys.mappings.o.tree.root.children.b.mapping.mode +string/which-key.keys.mappings.o.tree.root.children.b.mapping.label +boolean/which-key.keys.mappings.o.tree.root.children.b.mapping.opts.silent +string/which-key.keys.mappings.o.tree.root.children.b.mapping.opts.desc +boolean/which-key.keys.mappings.o.tree.root.children.b.mapping.opts.noremap +string/which-key.keys.mappings.o.tree.root.children.b.mapping.prefix +string/which-key.keys.mappings.o.tree.root.children.b.prefix_i +string/which-key.keys.mappings.o.tree.root.children.k.prefix_n +string/which-key.keys.mappings.o.tree.root.children.k.mapping.keys.keys +string/which-key.keys.mappings.o.tree.root.children.k.mapping.keys.notation.1 +string/which-key.keys.mappings.o.tree.root.children.k.mapping.keys.internal.1 +boolean/which-key.keys.mappings.o.tree.root.children.k.mapping.preset +string/which-key.keys.mappings.o.tree.root.children.k.mapping.mode +string/which-key.keys.mappings.o.tree.root.children.k.mapping.label +boolean/which-key.keys.mappings.o.tree.root.children.k.mapping.opts.silent +string/which-key.keys.mappings.o.tree.root.children.k.mapping.opts.desc +boolean/which-key.keys.mappings.o.tree.root.children.k.mapping.opts.noremap +string/which-key.keys.mappings.o.tree.root.children.k.mapping.prefix +string/which-key.keys.mappings.o.tree.root.children.k.prefix_i +string/which-key.keys.mappings.o.tree.root.children.l.prefix_n +string/which-key.keys.mappings.o.tree.root.children.l.mapping.keys.keys +string/which-key.keys.mappings.o.tree.root.children.l.mapping.keys.notation.1 +string/which-key.keys.mappings.o.tree.root.children.l.mapping.keys.internal.1 +boolean/which-key.keys.mappings.o.tree.root.children.l.mapping.preset +string/which-key.keys.mappings.o.tree.root.children.l.mapping.mode +string/which-key.keys.mappings.o.tree.root.children.l.mapping.label +boolean/which-key.keys.mappings.o.tree.root.children.l.mapping.opts.silent +string/which-key.keys.mappings.o.tree.root.children.l.mapping.opts.desc +boolean/which-key.keys.mappings.o.tree.root.children.l.mapping.opts.noremap +string/which-key.keys.mappings.o.tree.root.children.l.mapping.prefix +string/which-key.keys.mappings.o.tree.root.children.l.prefix_i +string/which-key.keys.mappings.o.tree.root.children.h.prefix_n +string/which-key.keys.mappings.o.tree.root.children.h.mapping.keys.keys +string/which-key.keys.mappings.o.tree.root.children.h.mapping.keys.notation.1 +string/which-key.keys.mappings.o.tree.root.children.h.mapping.keys.internal.1 +boolean/which-key.keys.mappings.o.tree.root.children.h.mapping.preset +string/which-key.keys.mappings.o.tree.root.children.h.mapping.mode +string/which-key.keys.mappings.o.tree.root.children.h.mapping.label +boolean/which-key.keys.mappings.o.tree.root.children.h.mapping.opts.silent +string/which-key.keys.mappings.o.tree.root.children.h.mapping.opts.desc +boolean/which-key.keys.mappings.o.tree.root.children.h.mapping.opts.noremap +string/which-key.keys.mappings.o.tree.root.children.h.mapping.prefix +string/which-key.keys.mappings.o.tree.root.children.h.prefix_i +string/which-key.keys.mappings.o.tree.root.children.g.prefix_n +string/which-key.keys.mappings.o.tree.root.children.g.mapping.keys.keys +string/which-key.keys.mappings.o.tree.root.children.g.mapping.keys.notation.1 +string/which-key.keys.mappings.o.tree.root.children.g.mapping.keys.internal.1 +string/which-key.keys.mappings.o.tree.root.children.g.mapping.prefix +boolean/which-key.keys.mappings.o.tree.root.children.g.mapping.group +string/which-key.keys.mappings.o.tree.root.children.g.children.e.prefix_n +string/which-key.keys.mappings.o.tree.root.children.g.children.e.mapping.keys.keys +string/which-key.keys.mappings.o.tree.root.children.g.children.e.mapping.keys.notation.1 +string/which-key.keys.mappings.o.tree.root.children.g.children.e.mapping.keys.notation.2 +string/which-key.keys.mappings.o.tree.root.children.g.children.e.mapping.keys.internal.1 +string/which-key.keys.mappings.o.tree.root.children.g.children.e.mapping.keys.internal.2 +boolean/which-key.keys.mappings.o.tree.root.children.g.children.e.mapping.preset +string/which-key.keys.mappings.o.tree.root.children.g.children.e.mapping.mode +string/which-key.keys.mappings.o.tree.root.children.g.children.e.mapping.label +boolean/which-key.keys.mappings.o.tree.root.children.g.children.e.mapping.opts.silent +string/which-key.keys.mappings.o.tree.root.children.g.children.e.mapping.opts.desc +boolean/which-key.keys.mappings.o.tree.root.children.g.children.e.mapping.opts.noremap +string/which-key.keys.mappings.o.tree.root.children.g.children.e.mapping.prefix +string/which-key.keys.mappings.o.tree.root.children.g.children.e.prefix_i +string/which-key.keys.mappings.o.tree.root.children.g.children.g.prefix_n +string/which-key.keys.mappings.o.tree.root.children.g.children.g.mapping.keys.keys +string/which-key.keys.mappings.o.tree.root.children.g.children.g.mapping.keys.notation.1 +string/which-key.keys.mappings.o.tree.root.children.g.children.g.mapping.keys.notation.2 +string/which-key.keys.mappings.o.tree.root.children.g.children.g.mapping.keys.internal.1 +string/which-key.keys.mappings.o.tree.root.children.g.children.g.mapping.keys.internal.2 +boolean/which-key.keys.mappings.o.tree.root.children.g.children.g.mapping.preset +string/which-key.keys.mappings.o.tree.root.children.g.children.g.mapping.mode +string/which-key.keys.mappings.o.tree.root.children.g.children.g.mapping.label +boolean/which-key.keys.mappings.o.tree.root.children.g.children.g.mapping.opts.silent +string/which-key.keys.mappings.o.tree.root.children.g.children.g.mapping.opts.desc +boolean/which-key.keys.mappings.o.tree.root.children.g.children.g.mapping.opts.noremap +string/which-key.keys.mappings.o.tree.root.children.g.children.g.mapping.prefix +string/which-key.keys.mappings.o.tree.root.children.g.children.g.prefix_i +string/which-key.keys.mappings.o.tree.root.children.g.children.%.prefix_n +string/which-key.keys.mappings.o.tree.root.children.g.children.%.mapping.keys.keys +string/which-key.keys.mappings.o.tree.root.children.g.children.%.mapping.keys.notation.1 +string/which-key.keys.mappings.o.tree.root.children.g.children.%.mapping.keys.notation.2 +string/which-key.keys.mappings.o.tree.root.children.g.children.%.mapping.keys.internal.1 +string/which-key.keys.mappings.o.tree.root.children.g.children.%.mapping.keys.internal.2 +string/which-key.keys.mappings.o.tree.root.children.g.children.%.mapping.id +string/which-key.keys.mappings.o.tree.root.children.g.children.%.mapping.prefix +string/which-key.keys.mappings.o.tree.root.children.g.children.%.mapping.cmd +string/which-key.keys.mappings.o.tree.root.children.g.children.%.prefix_i +string/which-key.keys.mappings.o.tree.root.children.g.prefix_i +string/which-key.keys.mappings.o.tree.root.children.f.prefix_n +string/which-key.keys.mappings.o.tree.root.children.f.mapping.keys.keys +string/which-key.keys.mappings.o.tree.root.children.f.mapping.keys.notation.1 +string/which-key.keys.mappings.o.tree.root.children.f.mapping.keys.internal.1 +boolean/which-key.keys.mappings.o.tree.root.children.f.mapping.preset +string/which-key.keys.mappings.o.tree.root.children.f.mapping.mode +string/which-key.keys.mappings.o.tree.root.children.f.mapping.label +boolean/which-key.keys.mappings.o.tree.root.children.f.mapping.opts.silent +string/which-key.keys.mappings.o.tree.root.children.f.mapping.opts.desc +boolean/which-key.keys.mappings.o.tree.root.children.f.mapping.opts.noremap +string/which-key.keys.mappings.o.tree.root.children.f.mapping.prefix +string/which-key.keys.mappings.o.tree.root.children.f.prefix_i +string/which-key.keys.mappings.o.tree.root.children.e.prefix_n +string/which-key.keys.mappings.o.tree.root.children.e.mapping.keys.keys +string/which-key.keys.mappings.o.tree.root.children.e.mapping.keys.notation.1 +string/which-key.keys.mappings.o.tree.root.children.e.mapping.keys.internal.1 +boolean/which-key.keys.mappings.o.tree.root.children.e.mapping.preset +string/which-key.keys.mappings.o.tree.root.children.e.mapping.mode +string/which-key.keys.mappings.o.tree.root.children.e.mapping.label +boolean/which-key.keys.mappings.o.tree.root.children.e.mapping.opts.silent +string/which-key.keys.mappings.o.tree.root.children.e.mapping.opts.desc +boolean/which-key.keys.mappings.o.tree.root.children.e.mapping.opts.noremap +string/which-key.keys.mappings.o.tree.root.children.e.mapping.prefix +string/which-key.keys.mappings.o.tree.root.children.e.prefix_i +string/which-key.keys.mappings.o.tree.root.children.t.prefix_n +string/which-key.keys.mappings.o.tree.root.children.t.mapping.keys.keys +string/which-key.keys.mappings.o.tree.root.children.t.mapping.keys.notation.1 +string/which-key.keys.mappings.o.tree.root.children.t.mapping.keys.internal.1 +boolean/which-key.keys.mappings.o.tree.root.children.t.mapping.preset +string/which-key.keys.mappings.o.tree.root.children.t.mapping.mode +string/which-key.keys.mappings.o.tree.root.children.t.mapping.label +boolean/which-key.keys.mappings.o.tree.root.children.t.mapping.opts.silent +string/which-key.keys.mappings.o.tree.root.children.t.mapping.opts.desc +boolean/which-key.keys.mappings.o.tree.root.children.t.mapping.opts.noremap +string/which-key.keys.mappings.o.tree.root.children.t.mapping.prefix +string/which-key.keys.mappings.o.tree.root.children.t.prefix_i +string/which-key.keys.mappings.o.tree.root.children.%.prefix_n +string/which-key.keys.mappings.o.tree.root.children.%.mapping.keys.keys +string/which-key.keys.mappings.o.tree.root.children.%.mapping.keys.notation.1 +string/which-key.keys.mappings.o.tree.root.children.%.mapping.keys.internal.1 +boolean/which-key.keys.mappings.o.tree.root.children.%.mapping.opts.silent +string/which-key.keys.mappings.o.tree.root.children.%.mapping.opts.desc +boolean/which-key.keys.mappings.o.tree.root.children.%.mapping.opts.noremap +string/which-key.keys.mappings.o.tree.root.children.%.mapping.mode +boolean/which-key.keys.mappings.o.tree.root.children.%.mapping.preset +string/which-key.keys.mappings.o.tree.root.children.%.mapping.id +string/which-key.keys.mappings.o.tree.root.children.%.mapping.label +string/which-key.keys.mappings.o.tree.root.children.%.mapping.prefix +string/which-key.keys.mappings.o.tree.root.children.%.mapping.cmd +string/which-key.keys.mappings.o.tree.root.children.%.prefix_i +string/which-key.keys.mappings.o.tree.root.children.{.prefix_n +string/which-key.keys.mappings.o.tree.root.children.{.mapping.keys.keys +string/which-key.keys.mappings.o.tree.root.children.{.mapping.keys.notation.1 +string/which-key.keys.mappings.o.tree.root.children.{.mapping.keys.internal.1 +boolean/which-key.keys.mappings.o.tree.root.children.{.mapping.preset +string/which-key.keys.mappings.o.tree.root.children.{.mapping.mode +string/which-key.keys.mappings.o.tree.root.children.{.mapping.label +boolean/which-key.keys.mappings.o.tree.root.children.{.mapping.opts.silent +string/which-key.keys.mappings.o.tree.root.children.{.mapping.opts.desc +boolean/which-key.keys.mappings.o.tree.root.children.{.mapping.opts.noremap +string/which-key.keys.mappings.o.tree.root.children.{.mapping.prefix +string/which-key.keys.mappings.o.tree.root.children.{.prefix_i +string/which-key.keys.mappings.o.tree.root.children.w.prefix_n +string/which-key.keys.mappings.o.tree.root.children.w.mapping.keys.keys +string/which-key.keys.mappings.o.tree.root.children.w.mapping.keys.notation.1 +string/which-key.keys.mappings.o.tree.root.children.w.mapping.keys.internal.1 +boolean/which-key.keys.mappings.o.tree.root.children.w.mapping.preset +string/which-key.keys.mappings.o.tree.root.children.w.mapping.mode +string/which-key.keys.mappings.o.tree.root.children.w.mapping.label +boolean/which-key.keys.mappings.o.tree.root.children.w.mapping.opts.silent +string/which-key.keys.mappings.o.tree.root.children.w.mapping.opts.desc +boolean/which-key.keys.mappings.o.tree.root.children.w.mapping.opts.noremap +string/which-key.keys.mappings.o.tree.root.children.w.mapping.prefix +string/which-key.keys.mappings.o.tree.root.children.w.prefix_i +string/which-key.keys.mappings.o.tree.root.children.T.prefix_n +string/which-key.keys.mappings.o.tree.root.children.T.mapping.keys.keys +string/which-key.keys.mappings.o.tree.root.children.T.mapping.keys.notation.1 +string/which-key.keys.mappings.o.tree.root.children.T.mapping.keys.internal.1 +boolean/which-key.keys.mappings.o.tree.root.children.T.mapping.preset +string/which-key.keys.mappings.o.tree.root.children.T.mapping.mode +string/which-key.keys.mappings.o.tree.root.children.T.mapping.label +boolean/which-key.keys.mappings.o.tree.root.children.T.mapping.opts.silent +string/which-key.keys.mappings.o.tree.root.children.T.mapping.opts.desc +boolean/which-key.keys.mappings.o.tree.root.children.T.mapping.opts.noremap +string/which-key.keys.mappings.o.tree.root.children.T.mapping.prefix +string/which-key.keys.mappings.o.tree.root.children.T.prefix_i +string/which-key.keys.mappings.o.tree.root.children.].prefix_n +string/which-key.keys.mappings.o.tree.root.children.].mapping.keys.keys +string/which-key.keys.mappings.o.tree.root.children.].mapping.keys.notation.1 +string/which-key.keys.mappings.o.tree.root.children.].mapping.keys.internal.1 +string/which-key.keys.mappings.o.tree.root.children.].mapping.prefix +boolean/which-key.keys.mappings.o.tree.root.children.].mapping.group +string/which-key.keys.mappings.o.tree.root.children.].children.%.prefix_n +string/which-key.keys.mappings.o.tree.root.children.].children.%.mapping.keys.keys +string/which-key.keys.mappings.o.tree.root.children.].children.%.mapping.keys.notation.1 +string/which-key.keys.mappings.o.tree.root.children.].children.%.mapping.keys.notation.2 +string/which-key.keys.mappings.o.tree.root.children.].children.%.mapping.keys.internal.1 +string/which-key.keys.mappings.o.tree.root.children.].children.%.mapping.keys.internal.2 +string/which-key.keys.mappings.o.tree.root.children.].children.%.mapping.id +string/which-key.keys.mappings.o.tree.root.children.].children.%.mapping.prefix +string/which-key.keys.mappings.o.tree.root.children.].children.%.mapping.cmd +string/which-key.keys.mappings.o.tree.root.children.].children.%.prefix_i +string/which-key.keys.mappings.o.tree.root.children.].prefix_i +string/which-key.keys.mappings.o.tree.root.children.0.prefix_n +string/which-key.keys.mappings.o.tree.root.children.0.mapping.keys.keys +string/which-key.keys.mappings.o.tree.root.children.0.mapping.keys.notation.1 +string/which-key.keys.mappings.o.tree.root.children.0.mapping.keys.internal.1 +boolean/which-key.keys.mappings.o.tree.root.children.0.mapping.preset +string/which-key.keys.mappings.o.tree.root.children.0.mapping.mode +string/which-key.keys.mappings.o.tree.root.children.0.mapping.label +boolean/which-key.keys.mappings.o.tree.root.children.0.mapping.opts.silent +string/which-key.keys.mappings.o.tree.root.children.0.mapping.opts.desc +boolean/which-key.keys.mappings.o.tree.root.children.0.mapping.opts.noremap +string/which-key.keys.mappings.o.tree.root.children.0.mapping.prefix +string/which-key.keys.mappings.o.tree.root.children.0.prefix_i +string/which-key.keys.mappings.o.tree.root.children.[.prefix_n +string/which-key.keys.mappings.o.tree.root.children.[.mapping.keys.keys +string/which-key.keys.mappings.o.tree.root.children.[.mapping.keys.notation.1 +string/which-key.keys.mappings.o.tree.root.children.[.mapping.keys.internal.1 +string/which-key.keys.mappings.o.tree.root.children.[.mapping.prefix +boolean/which-key.keys.mappings.o.tree.root.children.[.mapping.group +string/which-key.keys.mappings.o.tree.root.children.[.children.%.prefix_n +string/which-key.keys.mappings.o.tree.root.children.[.children.%.mapping.keys.keys +string/which-key.keys.mappings.o.tree.root.children.[.children.%.mapping.keys.notation.1 +string/which-key.keys.mappings.o.tree.root.children.[.children.%.mapping.keys.notation.2 +string/which-key.keys.mappings.o.tree.root.children.[.children.%.mapping.keys.internal.1 +string/which-key.keys.mappings.o.tree.root.children.[.children.%.mapping.keys.internal.2 +string/which-key.keys.mappings.o.tree.root.children.[.children.%.mapping.id +string/which-key.keys.mappings.o.tree.root.children.[.children.%.mapping.prefix +string/which-key.keys.mappings.o.tree.root.children.[.children.%.mapping.cmd +string/which-key.keys.mappings.o.tree.root.children.[.children.%.prefix_i +string/which-key.keys.mappings.o.tree.root.children.[.prefix_i +string/which-key.keys.mappings.o.tree.root.children.G.prefix_n +string/which-key.keys.mappings.o.tree.root.children.G.mapping.keys.keys +string/which-key.keys.mappings.o.tree.root.children.G.mapping.keys.notation.1 +string/which-key.keys.mappings.o.tree.root.children.G.mapping.keys.internal.1 +boolean/which-key.keys.mappings.o.tree.root.children.G.mapping.preset +string/which-key.keys.mappings.o.tree.root.children.G.mapping.mode +string/which-key.keys.mappings.o.tree.root.children.G.mapping.label +boolean/which-key.keys.mappings.o.tree.root.children.G.mapping.opts.silent +string/which-key.keys.mappings.o.tree.root.children.G.mapping.opts.desc +boolean/which-key.keys.mappings.o.tree.root.children.G.mapping.opts.noremap +string/which-key.keys.mappings.o.tree.root.children.G.mapping.prefix +string/which-key.keys.mappings.o.tree.root.children.G.prefix_i +string/which-key.keys.mappings.o.tree.root.children.$.prefix_n +string/which-key.keys.mappings.o.tree.root.children.$.mapping.keys.keys +string/which-key.keys.mappings.o.tree.root.children.$.mapping.keys.notation.1 +string/which-key.keys.mappings.o.tree.root.children.$.mapping.keys.internal.1 +boolean/which-key.keys.mappings.o.tree.root.children.$.mapping.preset +string/which-key.keys.mappings.o.tree.root.children.$.mapping.mode +string/which-key.keys.mappings.o.tree.root.children.$.mapping.label +boolean/which-key.keys.mappings.o.tree.root.children.$.mapping.opts.silent +string/which-key.keys.mappings.o.tree.root.children.$.mapping.opts.desc +boolean/which-key.keys.mappings.o.tree.root.children.$.mapping.opts.noremap +string/which-key.keys.mappings.o.tree.root.children.$.mapping.prefix +string/which-key.keys.mappings.o.tree.root.children.$.prefix_i +string/which-key.keys.mappings.o.tree.root.prefix_i +string/which-key.keys.mappings.o.mode +string/which-key.keys.mappings.o41.tree.root.prefix_n +string/which-key.keys.mappings.o41.tree.root.mapping.keys.keys +string/which-key.keys.mappings.o41.tree.root.mapping.prefix +boolean/which-key.keys.mappings.o41.tree.root.mapping.group +string/which-key.keys.mappings.o41.tree.root.prefix_i +string/which-key.keys.mappings.o41.mode +number/which-key.keys.mappings.o41.buf +string/which-key.keys.mappings.n22.tree.root.prefix_n +string/which-key.keys.mappings.n22.tree.root.mapping.keys.keys +string/which-key.keys.mappings.n22.tree.root.mapping.prefix +boolean/which-key.keys.mappings.n22.tree.root.mapping.group +string/which-key.keys.mappings.n22.tree.root.prefix_i +string/which-key.keys.mappings.n22.mode +number/which-key.keys.mappings.n22.buf +string/which-key.keys.mappings.n11.tree.root.prefix_n +string/which-key.keys.mappings.n11.tree.root.mapping.keys.keys +string/which-key.keys.mappings.n11.tree.root.mapping.prefix +boolean/which-key.keys.mappings.n11.tree.root.mapping.group +string/which-key.keys.mappings.n11.tree.root.prefix_i +string/which-key.keys.mappings.n11.mode +number/which-key.keys.mappings.n11.buf +string/which-key.keys.mappings.n59.tree.root.prefix_n +string/which-key.keys.mappings.n59.tree.root.mapping.keys.keys +string/which-key.keys.mappings.n59.tree.root.mapping.prefix +boolean/which-key.keys.mappings.n59.tree.root.mapping.group +string/which-key.keys.mappings.n59.tree.root.prefix_i +string/which-key.keys.mappings.n59.mode +number/which-key.keys.mappings.n59.buf +string/which-key.keys.mappings.v.tree.root.prefix_n +string/which-key.keys.mappings.v.tree.root.mapping.keys.keys +string/which-key.keys.mappings.v.tree.root.mapping.prefix +boolean/which-key.keys.mappings.v.tree.root.mapping.group +string/which-key.keys.mappings.v.tree.root.children.#.prefix_n +string/which-key.keys.mappings.v.tree.root.children.#.mapping.keys.keys +string/which-key.keys.mappings.v.tree.root.children.#.mapping.keys.notation.1 +string/which-key.keys.mappings.v.tree.root.children.#.mapping.keys.internal.1 +string/which-key.keys.mappings.v.tree.root.children.#.mapping.id +string/which-key.keys.mappings.v.tree.root.children.#.mapping.desc +string/which-key.keys.mappings.v.tree.root.children.#.mapping.prefix +string/which-key.keys.mappings.v.tree.root.children.#.mapping.cmd +string/which-key.keys.mappings.v.tree.root.children.#.prefix_i +string/which-key.keys.mappings.v.tree.root.children.<80>kB.prefix_n +string/which-key.keys.mappings.v.tree.root.children.<80>kB.mapping.keys.keys +string/which-key.keys.mappings.v.tree.root.children.<80>kB.mapping.keys.notation.1 +string/which-key.keys.mappings.v.tree.root.children.<80>kB.mapping.keys.internal.1 +string/which-key.keys.mappings.v.tree.root.children.<80>kB.mapping.desc +string/which-key.keys.mappings.v.tree.root.children.<80>kB.mapping.prefix +string/which-key.keys.mappings.v.tree.root.children.<80>kB.mapping.id +string/which-key.keys.mappings.v.tree.root.children.<80>kB.prefix_i +string/which-key.keys.mappings.v.tree.root.children.*.prefix_n +string/which-key.keys.mappings.v.tree.root.children.*.mapping.keys.keys +string/which-key.keys.mappings.v.tree.root.children.*.mapping.keys.notation.1 +string/which-key.keys.mappings.v.tree.root.children.*.mapping.keys.internal.1 +string/which-key.keys.mappings.v.tree.root.children.*.mapping.id +string/which-key.keys.mappings.v.tree.root.children.*.mapping.desc +string/which-key.keys.mappings.v.tree.root.children.*.mapping.prefix +string/which-key.keys.mappings.v.tree.root.children.*.mapping.cmd +string/which-key.keys.mappings.v.tree.root.children.*.prefix_i +string/which-key.keys.mappings.v.tree.root.children.a.prefix_n +string/which-key.keys.mappings.v.tree.root.children.a.mapping.keys.keys +string/which-key.keys.mappings.v.tree.root.children.a.mapping.keys.notation.1 +string/which-key.keys.mappings.v.tree.root.children.a.mapping.keys.internal.1 +string/which-key.keys.mappings.v.tree.root.children.a.mapping.mode +string/which-key.keys.mappings.v.tree.root.children.a.mapping.name +boolean/which-key.keys.mappings.v.tree.root.children.a.mapping.preset +boolean/which-key.keys.mappings.v.tree.root.children.a.mapping.group +string/which-key.keys.mappings.v.tree.root.children.a.mapping.label +string/which-key.keys.mappings.v.tree.root.children.a.mapping.prefix +boolean/which-key.keys.mappings.v.tree.root.children.a.mapping.opts.silent +boolean/which-key.keys.mappings.v.tree.root.children.a.mapping.opts.noremap +string/which-key.keys.mappings.v.tree.root.children.a.children.%.prefix_n +string/which-key.keys.mappings.v.tree.root.children.a.children.%.mapping.keys.keys +string/which-key.keys.mappings.v.tree.root.children.a.children.%.mapping.keys.notation.1 +string/which-key.keys.mappings.v.tree.root.children.a.children.%.mapping.keys.notation.2 +string/which-key.keys.mappings.v.tree.root.children.a.children.%.mapping.keys.internal.1 +string/which-key.keys.mappings.v.tree.root.children.a.children.%.mapping.keys.internal.2 +string/which-key.keys.mappings.v.tree.root.children.a.children.%.mapping.id +string/which-key.keys.mappings.v.tree.root.children.a.children.%.mapping.prefix +string/which-key.keys.mappings.v.tree.root.children.a.children.%.mapping.cmd +string/which-key.keys.mappings.v.tree.root.children.a.children.%.prefix_i +string/which-key.keys.mappings.v.tree.root.children.a.prefix_i +string/which-key.keys.mappings.v.tree.root.children.%.prefix_n +string/which-key.keys.mappings.v.tree.root.children.%.mapping.keys.keys +string/which-key.keys.mappings.v.tree.root.children.%.mapping.keys.notation.1 +string/which-key.keys.mappings.v.tree.root.children.%.mapping.keys.internal.1 +string/which-key.keys.mappings.v.tree.root.children.%.mapping.id +string/which-key.keys.mappings.v.tree.root.children.%.mapping.prefix +string/which-key.keys.mappings.v.tree.root.children.%.mapping.cmd +string/which-key.keys.mappings.v.tree.root.children.%.prefix_i +string/which-key.keys.mappings.v.tree.root.children. .prefix_n +string/which-key.keys.mappings.v.tree.root.children. .mapping.keys.keys +string/which-key.keys.mappings.v.tree.root.children. .mapping.keys.notation.1 +string/which-key.keys.mappings.v.tree.root.children. .mapping.keys.internal.1 +string/which-key.keys.mappings.v.tree.root.children. .mapping.prefix +boolean/which-key.keys.mappings.v.tree.root.children. .mapping.group +string/which-key.keys.mappings.v.tree.root.children. .children./.prefix_n +string/which-key.keys.mappings.v.tree.root.children. .children./.mapping.keys.keys +string/which-key.keys.mappings.v.tree.root.children. .children./.mapping.keys.notation.1 +string/which-key.keys.mappings.v.tree.root.children. .children./.mapping.keys.notation.2 +string/which-key.keys.mappings.v.tree.root.children. .children./.mapping.keys.internal.1 +string/which-key.keys.mappings.v.tree.root.children. .children./.mapping.keys.internal.2 +string/which-key.keys.mappings.v.tree.root.children. .children./.mapping.id +string/which-key.keys.mappings.v.tree.root.children. .children./.mapping.prefix +string/which-key.keys.mappings.v.tree.root.children. .children./.mapping.cmd +string/which-key.keys.mappings.v.tree.root.children. .children./.prefix_i +string/which-key.keys.mappings.v.tree.root.children. .prefix_i +string/which-key.keys.mappings.v.tree.root.children.".prefix_n +string/which-key.keys.mappings.v.tree.root.children.".mapping.keys.keys +string/which-key.keys.mappings.v.tree.root.children.".mapping.keys.notation.1 +string/which-key.keys.mappings.v.tree.root.children.".mapping.keys.internal.1 +boolean/which-key.keys.mappings.v.tree.root.children.".mapping.group +string/which-key.keys.mappings.v.tree.root.children.".mapping.prefix +string/which-key.keys.mappings.v.tree.root.children.".mapping.plugin +string/which-key.keys.mappings.v.tree.root.children.".mapping.label +boolean/which-key.keys.mappings.v.tree.root.children.".mapping.opts.silent +string/which-key.keys.mappings.v.tree.root.children.".mapping.opts.desc +boolean/which-key.keys.mappings.v.tree.root.children.".mapping.opts.noremap +string/which-key.keys.mappings.v.tree.root.children.".mapping.mode +string/which-key.keys.mappings.v.tree.root.children.".prefix_i +string/which-key.keys.mappings.v.tree.root.children.i.prefix_n +string/which-key.keys.mappings.v.tree.root.children.i.mapping.keys.keys +string/which-key.keys.mappings.v.tree.root.children.i.mapping.keys.notation.1 +string/which-key.keys.mappings.v.tree.root.children.i.mapping.keys.internal.1 +string/which-key.keys.mappings.v.tree.root.children.i.mapping.mode +string/which-key.keys.mappings.v.tree.root.children.i.mapping.name +boolean/which-key.keys.mappings.v.tree.root.children.i.mapping.preset +boolean/which-key.keys.mappings.v.tree.root.children.i.mapping.group +string/which-key.keys.mappings.v.tree.root.children.i.mapping.label +string/which-key.keys.mappings.v.tree.root.children.i.mapping.prefix +boolean/which-key.keys.mappings.v.tree.root.children.i.mapping.opts.silent +boolean/which-key.keys.mappings.v.tree.root.children.i.mapping.opts.noremap +string/which-key.keys.mappings.v.tree.root.children.i.prefix_i +string/which-key.keys.mappings.v.tree.root.children.^I.prefix_n +string/which-key.keys.mappings.v.tree.root.children.^I.mapping.keys.keys +string/which-key.keys.mappings.v.tree.root.children.^I.mapping.keys.notation.1 +string/which-key.keys.mappings.v.tree.root.children.^I.mapping.keys.internal.1 +string/which-key.keys.mappings.v.tree.root.children.^I.mapping.desc +string/which-key.keys.mappings.v.tree.root.children.^I.mapping.prefix +string/which-key.keys.mappings.v.tree.root.children.^I.mapping.id +string/which-key.keys.mappings.v.tree.root.children.^I.prefix_i +string/which-key.keys.mappings.v.tree.root.children.[.prefix_n +string/which-key.keys.mappings.v.tree.root.children.[.mapping.keys.keys +string/which-key.keys.mappings.v.tree.root.children.[.mapping.keys.notation.1 +string/which-key.keys.mappings.v.tree.root.children.[.mapping.keys.internal.1 +string/which-key.keys.mappings.v.tree.root.children.[.mapping.prefix +boolean/which-key.keys.mappings.v.tree.root.children.[.mapping.group +string/which-key.keys.mappings.v.tree.root.children.[.children.%.prefix_n +string/which-key.keys.mappings.v.tree.root.children.[.children.%.mapping.keys.keys +string/which-key.keys.mappings.v.tree.root.children.[.children.%.mapping.keys.notation.1 +string/which-key.keys.mappings.v.tree.root.children.[.children.%.mapping.keys.notation.2 +string/which-key.keys.mappings.v.tree.root.children.[.children.%.mapping.keys.internal.1 +string/which-key.keys.mappings.v.tree.root.children.[.children.%.mapping.keys.internal.2 +string/which-key.keys.mappings.v.tree.root.children.[.children.%.mapping.id +string/which-key.keys.mappings.v.tree.root.children.[.children.%.mapping.prefix +string/which-key.keys.mappings.v.tree.root.children.[.children.%.mapping.cmd +string/which-key.keys.mappings.v.tree.root.children.[.children.%.prefix_i +string/which-key.keys.mappings.v.tree.root.children.[.prefix_i +string/which-key.keys.mappings.v.tree.root.children.g.prefix_n +string/which-key.keys.mappings.v.tree.root.children.g.mapping.keys.keys +string/which-key.keys.mappings.v.tree.root.children.g.mapping.keys.notation.1 +string/which-key.keys.mappings.v.tree.root.children.g.mapping.keys.internal.1 +string/which-key.keys.mappings.v.tree.root.children.g.mapping.prefix +boolean/which-key.keys.mappings.v.tree.root.children.g.mapping.group +string/which-key.keys.mappings.v.tree.root.children.g.children.c.prefix_n +string/which-key.keys.mappings.v.tree.root.children.g.children.c.mapping.keys.keys +string/which-key.keys.mappings.v.tree.root.children.g.children.c.mapping.keys.notation.1 +string/which-key.keys.mappings.v.tree.root.children.g.children.c.mapping.keys.notation.2 +string/which-key.keys.mappings.v.tree.root.children.g.children.c.mapping.keys.internal.1 +string/which-key.keys.mappings.v.tree.root.children.g.children.c.mapping.keys.internal.2 +string/which-key.keys.mappings.v.tree.root.children.g.children.c.mapping.id +string/which-key.keys.mappings.v.tree.root.children.g.children.c.mapping.desc +string/which-key.keys.mappings.v.tree.root.children.g.children.c.mapping.prefix +string/which-key.keys.mappings.v.tree.root.children.g.children.c.mapping.cmd +string/which-key.keys.mappings.v.tree.root.children.g.children.c.prefix_i +string/which-key.keys.mappings.v.tree.root.children.g.children.%.prefix_n +string/which-key.keys.mappings.v.tree.root.children.g.children.%.mapping.keys.keys +string/which-key.keys.mappings.v.tree.root.children.g.children.%.mapping.keys.notation.1 +string/which-key.keys.mappings.v.tree.root.children.g.children.%.mapping.keys.notation.2 +string/which-key.keys.mappings.v.tree.root.children.g.children.%.mapping.keys.internal.1 +string/which-key.keys.mappings.v.tree.root.children.g.children.%.mapping.keys.internal.2 +string/which-key.keys.mappings.v.tree.root.children.g.children.%.mapping.id +string/which-key.keys.mappings.v.tree.root.children.g.children.%.mapping.prefix +string/which-key.keys.mappings.v.tree.root.children.g.children.%.mapping.cmd +string/which-key.keys.mappings.v.tree.root.children.g.children.%.prefix_i +string/which-key.keys.mappings.v.tree.root.children.g.children.b.prefix_n +string/which-key.keys.mappings.v.tree.root.children.g.children.b.mapping.keys.keys +string/which-key.keys.mappings.v.tree.root.children.g.children.b.mapping.keys.notation.1 +string/which-key.keys.mappings.v.tree.root.children.g.children.b.mapping.keys.notation.2 +string/which-key.keys.mappings.v.tree.root.children.g.children.b.mapping.keys.internal.1 +string/which-key.keys.mappings.v.tree.root.children.g.children.b.mapping.keys.internal.2 +string/which-key.keys.mappings.v.tree.root.children.g.children.b.mapping.id +string/which-key.keys.mappings.v.tree.root.children.g.children.b.mapping.desc +string/which-key.keys.mappings.v.tree.root.children.g.children.b.mapping.prefix +string/which-key.keys.mappings.v.tree.root.children.g.children.b.mapping.cmd +string/which-key.keys.mappings.v.tree.root.children.g.children.b.prefix_i +string/which-key.keys.mappings.v.tree.root.children.g.prefix_i +string/which-key.keys.mappings.v.tree.root.children.].prefix_n +string/which-key.keys.mappings.v.tree.root.children.].mapping.keys.keys +string/which-key.keys.mappings.v.tree.root.children.].mapping.keys.notation.1 +string/which-key.keys.mappings.v.tree.root.children.].mapping.keys.internal.1 +string/which-key.keys.mappings.v.tree.root.children.].mapping.prefix +boolean/which-key.keys.mappings.v.tree.root.children.].mapping.group +string/which-key.keys.mappings.v.tree.root.children.].children.%.prefix_n +string/which-key.keys.mappings.v.tree.root.children.].children.%.mapping.keys.keys +string/which-key.keys.mappings.v.tree.root.children.].children.%.mapping.keys.notation.1 +string/which-key.keys.mappings.v.tree.root.children.].children.%.mapping.keys.notation.2 +string/which-key.keys.mappings.v.tree.root.children.].children.%.mapping.keys.internal.1 +string/which-key.keys.mappings.v.tree.root.children.].children.%.mapping.keys.internal.2 +string/which-key.keys.mappings.v.tree.root.children.].children.%.mapping.id +string/which-key.keys.mappings.v.tree.root.children.].children.%.mapping.prefix +string/which-key.keys.mappings.v.tree.root.children.].children.%.mapping.cmd +string/which-key.keys.mappings.v.tree.root.children.].children.%.prefix_i +string/which-key.keys.mappings.v.tree.root.children.].prefix_i +string/which-key.keys.mappings.v.tree.root.prefix_i +string/which-key.keys.mappings.v.mode +string/which-key.keys.mappings.n25.tree.root.prefix_n +string/which-key.keys.mappings.n25.tree.root.mapping.keys.keys +string/which-key.keys.mappings.n25.tree.root.mapping.prefix +boolean/which-key.keys.mappings.n25.tree.root.mapping.group +string/which-key.keys.mappings.n25.tree.root.prefix_i +string/which-key.keys.mappings.n25.mode +number/which-key.keys.mappings.n25.buf +string/which-key.keys.mappings.n54.tree.root.prefix_n +string/which-key.keys.mappings.n54.tree.root.mapping.keys.keys +string/which-key.keys.mappings.n54.tree.root.mapping.prefix +boolean/which-key.keys.mappings.n54.tree.root.mapping.group +string/which-key.keys.mappings.n54.tree.root.prefix_i +string/which-key.keys.mappings.n54.mode +number/which-key.keys.mappings.n54.buf +string/which-key.keys.mappings.n64.tree.root.prefix_n +string/which-key.keys.mappings.n64.tree.root.mapping.keys.keys +string/which-key.keys.mappings.n64.tree.root.mapping.prefix +boolean/which-key.keys.mappings.n64.tree.root.mapping.group +string/which-key.keys.mappings.n64.tree.root.prefix_i +string/which-key.keys.mappings.n64.mode +number/which-key.keys.mappings.n64.buf +string/which-key.keys.mappings.n50.tree.root.prefix_n +string/which-key.keys.mappings.n50.tree.root.mapping.keys.keys +string/which-key.keys.mappings.n50.tree.root.mapping.prefix +boolean/which-key.keys.mappings.n50.tree.root.mapping.group +string/which-key.keys.mappings.n50.tree.root.prefix_i +string/which-key.keys.mappings.n50.mode +number/which-key.keys.mappings.n50.buf +string/which-key.keys.mappings.n42.tree.root.prefix_n +string/which-key.keys.mappings.n42.tree.root.mapping.keys.keys +string/which-key.keys.mappings.n42.tree.root.mapping.prefix +boolean/which-key.keys.mappings.n42.tree.root.mapping.group +string/which-key.keys.mappings.n42.tree.root.prefix_i +string/which-key.keys.mappings.n42.mode +number/which-key.keys.mappings.n42.buf +string/which-key.keys.mappings.c.tree.root.prefix_n +string/which-key.keys.mappings.c.tree.root.mapping.keys.keys +string/which-key.keys.mappings.c.tree.root.mapping.prefix +boolean/which-key.keys.mappings.c.tree.root.mapping.group +string/which-key.keys.mappings.c.tree.root.children.^R.prefix_n +string/which-key.keys.mappings.c.tree.root.children.^R.mapping.keys.keys +string/which-key.keys.mappings.c.tree.root.children.^R.mapping.keys.notation.1 +string/which-key.keys.mappings.c.tree.root.children.^R.mapping.keys.internal.1 +boolean/which-key.keys.mappings.c.tree.root.children.^R.mapping.group +string/which-key.keys.mappings.c.tree.root.children.^R.mapping.prefix +string/which-key.keys.mappings.c.tree.root.children.^R.mapping.plugin +string/which-key.keys.mappings.c.tree.root.children.^R.mapping.label +boolean/which-key.keys.mappings.c.tree.root.children.^R.mapping.opts.silent +string/which-key.keys.mappings.c.tree.root.children.^R.mapping.opts.desc +boolean/which-key.keys.mappings.c.tree.root.children.^R.mapping.opts.noremap +string/which-key.keys.mappings.c.tree.root.children.^R.mapping.mode +string/which-key.keys.mappings.c.tree.root.children.^R.prefix_i +string/which-key.keys.mappings.c.tree.root.prefix_i +string/which-key.keys.mappings.c.mode +string/which-key.keys.mappings.o26.tree.root.prefix_n +string/which-key.keys.mappings.o26.tree.root.mapping.keys.keys +string/which-key.keys.mappings.o26.tree.root.mapping.prefix +boolean/which-key.keys.mappings.o26.tree.root.mapping.group +string/which-key.keys.mappings.o26.tree.root.prefix_i +string/which-key.keys.mappings.o26.mode +number/which-key.keys.mappings.o26.buf +string/which-key.keys.mappings.n26.tree.root.prefix_n +string/which-key.keys.mappings.n26.tree.root.mapping.keys.keys +string/which-key.keys.mappings.n26.tree.root.mapping.prefix +boolean/which-key.keys.mappings.n26.tree.root.mapping.group +string/which-key.keys.mappings.n26.tree.root.prefix_i +string/which-key.keys.mappings.n26.mode +number/which-key.keys.mappings.n26.buf +string/which-key.keys.mappings.n41.tree.root.prefix_n +string/which-key.keys.mappings.n41.tree.root.mapping.keys.keys +string/which-key.keys.mappings.n41.tree.root.mapping.prefix +boolean/which-key.keys.mappings.n41.tree.root.mapping.group +string/which-key.keys.mappings.n41.tree.root.prefix_i +string/which-key.keys.mappings.n41.mode +number/which-key.keys.mappings.n41.buf +string/which-key.keys.mappings.n20.tree.root.prefix_n +string/which-key.keys.mappings.n20.tree.root.mapping.keys.keys +string/which-key.keys.mappings.n20.tree.root.mapping.prefix +boolean/which-key.keys.mappings.n20.tree.root.mapping.group +string/which-key.keys.mappings.n20.tree.root.prefix_i +string/which-key.keys.mappings.n20.mode +number/which-key.keys.mappings.n20.buf +string/which-key.keys.mappings.n37.tree.root.prefix_n +string/which-key.keys.mappings.n37.tree.root.mapping.keys.keys +string/which-key.keys.mappings.n37.tree.root.mapping.prefix +boolean/which-key.keys.mappings.n37.tree.root.mapping.group +string/which-key.keys.mappings.n37.tree.root.prefix_i +string/which-key.keys.mappings.n37.mode +number/which-key.keys.mappings.n37.buf +string/which-key.keys.mappings.n1.tree.root.prefix_n +string/which-key.keys.mappings.n1.tree.root.mapping.keys.keys +string/which-key.keys.mappings.n1.tree.root.mapping.prefix +boolean/which-key.keys.mappings.n1.tree.root.mapping.group +string/which-key.keys.mappings.n1.tree.root.prefix_i +string/which-key.keys.mappings.n1.mode +number/which-key.keys.mappings.n1.buf +string/which-key.keys.mappings.o1.tree.root.prefix_n +string/which-key.keys.mappings.o1.tree.root.mapping.keys.keys +string/which-key.keys.mappings.o1.tree.root.mapping.prefix +boolean/which-key.keys.mappings.o1.tree.root.mapping.group +string/which-key.keys.mappings.o1.tree.root.prefix_i +string/which-key.keys.mappings.o1.mode +number/which-key.keys.mappings.o1.buf +string/which-key.keys.mappings.n47.tree.root.prefix_n +string/which-key.keys.mappings.n47.tree.root.mapping.keys.keys +string/which-key.keys.mappings.n47.tree.root.mapping.prefix +boolean/which-key.keys.mappings.n47.tree.root.mapping.group +string/which-key.keys.mappings.n47.tree.root.prefix_i +string/which-key.keys.mappings.n47.mode +number/which-key.keys.mappings.n47.buf +string/which-key.keys.mappings.n.tree.root.prefix_n +string/which-key.keys.mappings.n.tree.root.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.mapping.prefix +boolean/which-key.keys.mappings.n.tree.root.mapping.group +string/which-key.keys.mappings.n.tree.root.children.^L.prefix_n +string/which-key.keys.mappings.n.tree.root.children.^L.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.^L.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.^L.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.^L.mapping.id +string/which-key.keys.mappings.n.tree.root.children.^L.mapping.desc +string/which-key.keys.mappings.n.tree.root.children.^L.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.^L.mapping.cmd +string/which-key.keys.mappings.n.tree.root.children.^L.prefix_i +string/which-key.keys.mappings.n.tree.root.children.j.prefix_n +string/which-key.keys.mappings.n.tree.root.children.j.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.j.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.j.mapping.keys.internal.1 +boolean/which-key.keys.mappings.n.tree.root.children.j.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.j.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.j.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.j.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.j.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.j.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.j.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.j.prefix_i +string/which-key.keys.mappings.n.tree.root.children.!.prefix_n +string/which-key.keys.mappings.n.tree.root.children.!.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.!.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.!.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.!.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.!.mapping.name +boolean/which-key.keys.mappings.n.tree.root.children.!.mapping.preset +boolean/which-key.keys.mappings.n.tree.root.children.!.mapping.group +string/which-key.keys.mappings.n.tree.root.children.!.mapping.label +string/which-key.keys.mappings.n.tree.root.children.!.mapping.prefix +boolean/which-key.keys.mappings.n.tree.root.children.!.mapping.opts.silent +boolean/which-key.keys.mappings.n.tree.root.children.!.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.!.children.a.prefix_n +string/which-key.keys.mappings.n.tree.root.children.!.children.a.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.!.children.a.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.!.children.a.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.!.children.a.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.!.children.a.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children.!.children.a.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.!.children.a.mapping.name +boolean/which-key.keys.mappings.n.tree.root.children.!.children.a.mapping.preset +boolean/which-key.keys.mappings.n.tree.root.children.!.children.a.mapping.group +string/which-key.keys.mappings.n.tree.root.children.!.children.a.mapping.label +string/which-key.keys.mappings.n.tree.root.children.!.children.a.mapping.mode +boolean/which-key.keys.mappings.n.tree.root.children.!.children.a.mapping.opts.silent +boolean/which-key.keys.mappings.n.tree.root.children.!.children.a.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.!.children.a.prefix_i +string/which-key.keys.mappings.n.tree.root.children.!.children.i.prefix_n +string/which-key.keys.mappings.n.tree.root.children.!.children.i.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.!.children.i.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.!.children.i.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.!.children.i.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.!.children.i.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children.!.children.i.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.!.children.i.mapping.name +boolean/which-key.keys.mappings.n.tree.root.children.!.children.i.mapping.preset +boolean/which-key.keys.mappings.n.tree.root.children.!.children.i.mapping.group +string/which-key.keys.mappings.n.tree.root.children.!.children.i.mapping.label +string/which-key.keys.mappings.n.tree.root.children.!.children.i.mapping.mode +boolean/which-key.keys.mappings.n.tree.root.children.!.children.i.mapping.opts.silent +boolean/which-key.keys.mappings.n.tree.root.children.!.children.i.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.!.children.i.prefix_i +string/which-key.keys.mappings.n.tree.root.children.!.prefix_i +string/which-key.keys.mappings.n.tree.root.children.H.prefix_n +string/which-key.keys.mappings.n.tree.root.children.H.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.H.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.H.mapping.keys.internal.1 +boolean/which-key.keys.mappings.n.tree.root.children.H.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.H.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.H.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.H.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.H.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.H.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.H.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.H.prefix_i +string/which-key.keys.mappings.n.tree.root.children.<.prefix_n +string/which-key.keys.mappings.n.tree.root.children.<.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.<.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.<.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.<.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.<.mapping.name +boolean/which-key.keys.mappings.n.tree.root.children.<.mapping.preset +boolean/which-key.keys.mappings.n.tree.root.children.<.mapping.group +string/which-key.keys.mappings.n.tree.root.children.<.mapping.label +string/which-key.keys.mappings.n.tree.root.children.<.mapping.prefix +boolean/which-key.keys.mappings.n.tree.root.children.<.mapping.opts.silent +boolean/which-key.keys.mappings.n.tree.root.children.<.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.<.children.a.prefix_n +string/which-key.keys.mappings.n.tree.root.children.<.children.a.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.<.children.a.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.<.children.a.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.<.children.a.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.<.children.a.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children.<.children.a.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.<.children.a.mapping.name +boolean/which-key.keys.mappings.n.tree.root.children.<.children.a.mapping.preset +boolean/which-key.keys.mappings.n.tree.root.children.<.children.a.mapping.group +string/which-key.keys.mappings.n.tree.root.children.<.children.a.mapping.label +string/which-key.keys.mappings.n.tree.root.children.<.children.a.mapping.mode +boolean/which-key.keys.mappings.n.tree.root.children.<.children.a.mapping.opts.silent +boolean/which-key.keys.mappings.n.tree.root.children.<.children.a.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.<.children.a.prefix_i +string/which-key.keys.mappings.n.tree.root.children.<.children.i.prefix_n +string/which-key.keys.mappings.n.tree.root.children.<.children.i.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.<.children.i.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.<.children.i.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.<.children.i.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.<.children.i.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children.<.children.i.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.<.children.i.mapping.name +boolean/which-key.keys.mappings.n.tree.root.children.<.children.i.mapping.preset +boolean/which-key.keys.mappings.n.tree.root.children.<.children.i.mapping.group +string/which-key.keys.mappings.n.tree.root.children.<.children.i.mapping.label +string/which-key.keys.mappings.n.tree.root.children.<.children.i.mapping.mode +boolean/which-key.keys.mappings.n.tree.root.children.<.children.i.mapping.opts.silent +boolean/which-key.keys.mappings.n.tree.root.children.<.children.i.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.<.children.i.prefix_i +string/which-key.keys.mappings.n.tree.root.children.<.prefix_i +string/which-key.keys.mappings.n.tree.root.children.>.prefix_n +string/which-key.keys.mappings.n.tree.root.children.>.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.>.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.>.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.>.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.>.mapping.name +boolean/which-key.keys.mappings.n.tree.root.children.>.mapping.preset +boolean/which-key.keys.mappings.n.tree.root.children.>.mapping.group +string/which-key.keys.mappings.n.tree.root.children.>.mapping.label +string/which-key.keys.mappings.n.tree.root.children.>.mapping.prefix +boolean/which-key.keys.mappings.n.tree.root.children.>.mapping.opts.silent +boolean/which-key.keys.mappings.n.tree.root.children.>.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.>.children.a.prefix_n +string/which-key.keys.mappings.n.tree.root.children.>.children.a.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.>.children.a.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.>.children.a.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.>.children.a.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.>.children.a.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children.>.children.a.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.>.children.a.mapping.name +boolean/which-key.keys.mappings.n.tree.root.children.>.children.a.mapping.preset +boolean/which-key.keys.mappings.n.tree.root.children.>.children.a.mapping.group +string/which-key.keys.mappings.n.tree.root.children.>.children.a.mapping.label +string/which-key.keys.mappings.n.tree.root.children.>.children.a.mapping.mode +boolean/which-key.keys.mappings.n.tree.root.children.>.children.a.mapping.opts.silent +boolean/which-key.keys.mappings.n.tree.root.children.>.children.a.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.>.children.a.prefix_i +string/which-key.keys.mappings.n.tree.root.children.>.children.i.prefix_n +string/which-key.keys.mappings.n.tree.root.children.>.children.i.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.>.children.i.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.>.children.i.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.>.children.i.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.>.children.i.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children.>.children.i.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.>.children.i.mapping.name +boolean/which-key.keys.mappings.n.tree.root.children.>.children.i.mapping.preset +boolean/which-key.keys.mappings.n.tree.root.children.>.children.i.mapping.group +string/which-key.keys.mappings.n.tree.root.children.>.children.i.mapping.label +string/which-key.keys.mappings.n.tree.root.children.>.children.i.mapping.mode +boolean/which-key.keys.mappings.n.tree.root.children.>.children.i.mapping.opts.silent +boolean/which-key.keys.mappings.n.tree.root.children.>.children.i.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.>.children.i.prefix_i +string/which-key.keys.mappings.n.tree.root.children.>.prefix_i +string/which-key.keys.mappings.n.tree.root.children.b.prefix_n +string/which-key.keys.mappings.n.tree.root.children.b.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.b.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.b.mapping.keys.internal.1 +boolean/which-key.keys.mappings.n.tree.root.children.b.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.b.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.b.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.b.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.b.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.b.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.b.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.b.prefix_i +string/which-key.keys.mappings.n.tree.root.children.l.prefix_n +string/which-key.keys.mappings.n.tree.root.children.l.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.l.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.l.mapping.keys.internal.1 +boolean/which-key.keys.mappings.n.tree.root.children.l.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.l.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.l.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.l.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.l.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.l.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.l.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.l.prefix_i +string/which-key.keys.mappings.n.tree.root.children.z.prefix_n +string/which-key.keys.mappings.n.tree.root.children.z.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.z.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.z.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.z.mapping.prefix +boolean/which-key.keys.mappings.n.tree.root.children.z.mapping.group +string/which-key.keys.mappings.n.tree.root.children.z.children.o.prefix_n +string/which-key.keys.mappings.n.tree.root.children.z.children.o.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.z.children.o.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.z.children.o.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.z.children.o.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.z.children.o.mapping.keys.internal.2 +boolean/which-key.keys.mappings.n.tree.root.children.z.children.o.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.z.children.o.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.z.children.o.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.z.children.o.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.z.children.o.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.z.children.o.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.z.children.o.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.z.children.o.prefix_i +string/which-key.keys.mappings.n.tree.root.children.z.children.x.prefix_n +string/which-key.keys.mappings.n.tree.root.children.z.children.x.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.z.children.x.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.z.children.x.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.z.children.x.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.z.children.x.mapping.keys.internal.2 +boolean/which-key.keys.mappings.n.tree.root.children.z.children.x.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.z.children.x.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.z.children.x.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.z.children.x.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.z.children.x.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.z.children.x.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.z.children.x.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.z.children.x.prefix_i +string/which-key.keys.mappings.n.tree.root.children.z.children.H.prefix_n +string/which-key.keys.mappings.n.tree.root.children.z.children.H.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.z.children.H.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.z.children.H.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.z.children.H.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.z.children.H.mapping.keys.internal.2 +boolean/which-key.keys.mappings.n.tree.root.children.z.children.H.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.z.children.H.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.z.children.H.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.z.children.H.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.z.children.H.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.z.children.H.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.z.children.H.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.z.children.H.prefix_i +string/which-key.keys.mappings.n.tree.root.children.z.children.r.prefix_n +string/which-key.keys.mappings.n.tree.root.children.z.children.r.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.z.children.r.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.z.children.r.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.z.children.r.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.z.children.r.mapping.keys.internal.2 +boolean/which-key.keys.mappings.n.tree.root.children.z.children.r.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.z.children.r.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.z.children.r.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.z.children.r.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.z.children.r.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.z.children.r.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.z.children.r.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.z.children.r.prefix_i +string/which-key.keys.mappings.n.tree.root.children.z.children.v.prefix_n +string/which-key.keys.mappings.n.tree.root.children.z.children.v.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.z.children.v.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.z.children.v.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.z.children.v.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.z.children.v.mapping.keys.internal.2 +boolean/which-key.keys.mappings.n.tree.root.children.z.children.v.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.z.children.v.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.z.children.v.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.z.children.v.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.z.children.v.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.z.children.v.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.z.children.v.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.z.children.v.prefix_i +string/which-key.keys.mappings.n.tree.root.children.z.children.w.prefix_n +string/which-key.keys.mappings.n.tree.root.children.z.children.w.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.z.children.w.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.z.children.w.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.z.children.w.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.z.children.w.mapping.keys.internal.2 +boolean/which-key.keys.mappings.n.tree.root.children.z.children.w.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.z.children.w.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.z.children.w.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.z.children.w.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.z.children.w.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.z.children.w.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.z.children.w.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.z.children.w.prefix_i +string/which-key.keys.mappings.n.tree.root.children.z.children.b.prefix_n +string/which-key.keys.mappings.n.tree.root.children.z.children.b.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.z.children.b.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.z.children.b.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.z.children.b.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.z.children.b.mapping.keys.internal.2 +boolean/which-key.keys.mappings.n.tree.root.children.z.children.b.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.z.children.b.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.z.children.b.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.z.children.b.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.z.children.b.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.z.children.b.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.z.children.b.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.z.children.b.prefix_i +string/which-key.keys.mappings.n.tree.root.children.z.children.=.prefix_n +string/which-key.keys.mappings.n.tree.root.children.z.children.=.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.z.children.=.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.z.children.=.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.z.children.=.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.z.children.=.mapping.keys.internal.2 +boolean/which-key.keys.mappings.n.tree.root.children.z.children.=.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.z.children.=.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.z.children.=.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.z.children.=.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.z.children.=.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.z.children.=.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.z.children.=.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.z.children.=.prefix_i +string/which-key.keys.mappings.n.tree.root.children.z.children.s.prefix_n +string/which-key.keys.mappings.n.tree.root.children.z.children.s.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.z.children.s.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.z.children.s.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.z.children.s.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.z.children.s.mapping.keys.internal.2 +boolean/which-key.keys.mappings.n.tree.root.children.z.children.s.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.z.children.s.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.z.children.s.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.z.children.s.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.z.children.s.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.z.children.s.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.z.children.s.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.z.children.s.prefix_i +string/which-key.keys.mappings.n.tree.root.children.z.children.R.prefix_n +string/which-key.keys.mappings.n.tree.root.children.z.children.R.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.z.children.R.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.z.children.R.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.z.children.R.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.z.children.R.mapping.keys.internal.2 +boolean/which-key.keys.mappings.n.tree.root.children.z.children.R.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.z.children.R.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.z.children.R.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.z.children.R.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.z.children.R.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.z.children.R.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.z.children.R.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.z.children.R.prefix_i +string/which-key.keys.mappings.n.tree.root.children.z.children.z.prefix_n +string/which-key.keys.mappings.n.tree.root.children.z.children.z.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.z.children.z.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.z.children.z.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.z.children.z.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.z.children.z.mapping.keys.internal.2 +boolean/which-key.keys.mappings.n.tree.root.children.z.children.z.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.z.children.z.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.z.children.z.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.z.children.z.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.z.children.z.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.z.children.z.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.z.children.z.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.z.children.z.prefix_i +string/which-key.keys.mappings.n.tree.root.children.z.children.c.prefix_n +string/which-key.keys.mappings.n.tree.root.children.z.children.c.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.z.children.c.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.z.children.c.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.z.children.c.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.z.children.c.mapping.keys.internal.2 +boolean/which-key.keys.mappings.n.tree.root.children.z.children.c.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.z.children.c.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.z.children.c.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.z.children.c.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.z.children.c.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.z.children.c.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.z.children.c.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.z.children.c.prefix_i +string/which-key.keys.mappings.n.tree.root.children.z.children.e.prefix_n +string/which-key.keys.mappings.n.tree.root.children.z.children.e.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.z.children.e.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.z.children.e.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.z.children.e.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.z.children.e.mapping.keys.internal.2 +boolean/which-key.keys.mappings.n.tree.root.children.z.children.e.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.z.children.e.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.z.children.e.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.z.children.e.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.z.children.e.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.z.children.e.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.z.children.e.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.z.children.e.prefix_i +string/which-key.keys.mappings.n.tree.root.children.z.children.m.prefix_n +string/which-key.keys.mappings.n.tree.root.children.z.children.m.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.z.children.m.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.z.children.m.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.z.children.m.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.z.children.m.mapping.keys.internal.2 +boolean/which-key.keys.mappings.n.tree.root.children.z.children.m.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.z.children.m.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.z.children.m.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.z.children.m.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.z.children.m.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.z.children.m.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.z.children.m.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.z.children.m.prefix_i +string/which-key.keys.mappings.n.tree.root.children.z.children.C.prefix_n +string/which-key.keys.mappings.n.tree.root.children.z.children.C.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.z.children.C.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.z.children.C.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.z.children.C.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.z.children.C.mapping.keys.internal.2 +boolean/which-key.keys.mappings.n.tree.root.children.z.children.C.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.z.children.C.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.z.children.C.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.z.children.C.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.z.children.C.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.z.children.C.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.z.children.C.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.z.children.C.prefix_i +string/which-key.keys.mappings.n.tree.root.children.z.children.L.prefix_n +string/which-key.keys.mappings.n.tree.root.children.z.children.L.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.z.children.L.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.z.children.L.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.z.children.L.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.z.children.L.mapping.keys.internal.2 +boolean/which-key.keys.mappings.n.tree.root.children.z.children.L.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.z.children.L.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.z.children.L.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.z.children.L.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.z.children.L.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.z.children.L.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.z.children.L.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.z.children.L.prefix_i +string/which-key.keys.mappings.n.tree.root.children.z.children.f.prefix_n +string/which-key.keys.mappings.n.tree.root.children.z.children.f.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.z.children.f.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.z.children.f.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.z.children.f.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.z.children.f.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children.z.children.f.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.z.children.f.mapping.name +boolean/which-key.keys.mappings.n.tree.root.children.z.children.f.mapping.preset +boolean/which-key.keys.mappings.n.tree.root.children.z.children.f.mapping.group +string/which-key.keys.mappings.n.tree.root.children.z.children.f.mapping.label +string/which-key.keys.mappings.n.tree.root.children.z.children.f.mapping.prefix +boolean/which-key.keys.mappings.n.tree.root.children.z.children.f.mapping.opts.silent +boolean/which-key.keys.mappings.n.tree.root.children.z.children.f.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.z.children.f.children.a.prefix_n +string/which-key.keys.mappings.n.tree.root.children.z.children.f.children.a.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.z.children.f.children.a.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.z.children.f.children.a.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.z.children.f.children.a.mapping.keys.notation.3 +string/which-key.keys.mappings.n.tree.root.children.z.children.f.children.a.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.z.children.f.children.a.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children.z.children.f.children.a.mapping.keys.internal.3 +string/which-key.keys.mappings.n.tree.root.children.z.children.f.children.a.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.z.children.f.children.a.mapping.name +boolean/which-key.keys.mappings.n.tree.root.children.z.children.f.children.a.mapping.preset +boolean/which-key.keys.mappings.n.tree.root.children.z.children.f.children.a.mapping.group +string/which-key.keys.mappings.n.tree.root.children.z.children.f.children.a.mapping.label +string/which-key.keys.mappings.n.tree.root.children.z.children.f.children.a.mapping.mode +boolean/which-key.keys.mappings.n.tree.root.children.z.children.f.children.a.mapping.opts.silent +boolean/which-key.keys.mappings.n.tree.root.children.z.children.f.children.a.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.z.children.f.children.a.prefix_i +string/which-key.keys.mappings.n.tree.root.children.z.children.f.children.i.prefix_n +string/which-key.keys.mappings.n.tree.root.children.z.children.f.children.i.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.z.children.f.children.i.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.z.children.f.children.i.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.z.children.f.children.i.mapping.keys.notation.3 +string/which-key.keys.mappings.n.tree.root.children.z.children.f.children.i.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.z.children.f.children.i.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children.z.children.f.children.i.mapping.keys.internal.3 +string/which-key.keys.mappings.n.tree.root.children.z.children.f.children.i.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.z.children.f.children.i.mapping.name +boolean/which-key.keys.mappings.n.tree.root.children.z.children.f.children.i.mapping.preset +boolean/which-key.keys.mappings.n.tree.root.children.z.children.f.children.i.mapping.group +string/which-key.keys.mappings.n.tree.root.children.z.children.f.children.i.mapping.label +string/which-key.keys.mappings.n.tree.root.children.z.children.f.children.i.mapping.mode +boolean/which-key.keys.mappings.n.tree.root.children.z.children.f.children.i.mapping.opts.silent +boolean/which-key.keys.mappings.n.tree.root.children.z.children.f.children.i.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.z.children.f.children.i.prefix_i +string/which-key.keys.mappings.n.tree.root.children.z.children.f.prefix_i +string/which-key.keys.mappings.n.tree.root.children.z.children.g.prefix_n +string/which-key.keys.mappings.n.tree.root.children.z.children.g.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.z.children.g.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.z.children.g.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.z.children.g.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.z.children.g.mapping.keys.internal.2 +boolean/which-key.keys.mappings.n.tree.root.children.z.children.g.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.z.children.g.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.z.children.g.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.z.children.g.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.z.children.g.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.z.children.g.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.z.children.g.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.z.children.g.prefix_i +string/which-key.keys.mappings.n.tree.root.children.z.children.M.prefix_n +string/which-key.keys.mappings.n.tree.root.children.z.children.M.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.z.children.M.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.z.children.M.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.z.children.M.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.z.children.M.mapping.keys.internal.2 +boolean/which-key.keys.mappings.n.tree.root.children.z.children.M.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.z.children.M.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.z.children.M.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.z.children.M.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.z.children.M.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.z.children.M.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.z.children.M.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.z.children.M.prefix_i +string/which-key.keys.mappings.n.tree.root.children.z.children.A.prefix_n +string/which-key.keys.mappings.n.tree.root.children.z.children.A.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.z.children.A.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.z.children.A.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.z.children.A.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.z.children.A.mapping.keys.internal.2 +boolean/which-key.keys.mappings.n.tree.root.children.z.children.A.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.z.children.A.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.z.children.A.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.z.children.A.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.z.children.A.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.z.children.A.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.z.children.A.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.z.children.A.prefix_i +string/which-key.keys.mappings.n.tree.root.children.z.children.O.prefix_n +string/which-key.keys.mappings.n.tree.root.children.z.children.O.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.z.children.O.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.z.children.O.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.z.children.O.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.z.children.O.mapping.keys.internal.2 +boolean/which-key.keys.mappings.n.tree.root.children.z.children.O.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.z.children.O.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.z.children.O.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.z.children.O.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.z.children.O.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.z.children.O.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.z.children.O.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.z.children.O.prefix_i +string/which-key.keys.mappings.n.tree.root.children.z.children.t.prefix_n +string/which-key.keys.mappings.n.tree.root.children.z.children.t.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.z.children.t.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.z.children.t.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.z.children.t.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.z.children.t.mapping.keys.internal.2 +boolean/which-key.keys.mappings.n.tree.root.children.z.children.t.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.z.children.t.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.z.children.t.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.z.children.t.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.z.children.t.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.z.children.t.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.z.children.t.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.z.children.t.prefix_i +string/which-key.keys.mappings.n.tree.root.children.z.children.a.prefix_n +string/which-key.keys.mappings.n.tree.root.children.z.children.a.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.z.children.a.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.z.children.a.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.z.children.a.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.z.children.a.mapping.keys.internal.2 +boolean/which-key.keys.mappings.n.tree.root.children.z.children.a.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.z.children.a.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.z.children.a.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.z.children.a.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.z.children.a.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.z.children.a.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.z.children.a.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.z.children.a.prefix_i +string/which-key.keys.mappings.n.tree.root.children.z.prefix_i +string/which-key.keys.mappings.n.tree.root.children.t.prefix_n +string/which-key.keys.mappings.n.tree.root.children.t.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.t.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.t.mapping.keys.internal.1 +boolean/which-key.keys.mappings.n.tree.root.children.t.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.t.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.t.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.t.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.t.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.t.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.t.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.t.prefix_i +string/which-key.keys.mappings.n.tree.root.children.`.prefix_n +string/which-key.keys.mappings.n.tree.root.children.`.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.`.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.`.mapping.keys.internal.1 +boolean/which-key.keys.mappings.n.tree.root.children.`.mapping.group +string/which-key.keys.mappings.n.tree.root.children.`.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.`.mapping.plugin +string/which-key.keys.mappings.n.tree.root.children.`.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.`.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.`.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.`.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.`.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.`.prefix_i +string/which-key.keys.mappings.n.tree.root.children.L.prefix_n +string/which-key.keys.mappings.n.tree.root.children.L.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.L.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.L.mapping.keys.internal.1 +boolean/which-key.keys.mappings.n.tree.root.children.L.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.L.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.L.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.L.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.L.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.L.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.L.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.L.prefix_i +string/which-key.keys.mappings.n.tree.root.children.G.prefix_n +string/which-key.keys.mappings.n.tree.root.children.G.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.G.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.G.mapping.keys.internal.1 +boolean/which-key.keys.mappings.n.tree.root.children.G.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.G.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.G.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.G.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.G.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.G.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.G.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.G.prefix_i +string/which-key.keys.mappings.n.tree.root.children.T.prefix_n +string/which-key.keys.mappings.n.tree.root.children.T.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.T.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.T.mapping.keys.internal.1 +boolean/which-key.keys.mappings.n.tree.root.children.T.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.T.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.T.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.T.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.T.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.T.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.T.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.T.prefix_i +string/which-key.keys.mappings.n.tree.root.children.0.prefix_n +string/which-key.keys.mappings.n.tree.root.children.0.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.0.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.0.mapping.keys.internal.1 +boolean/which-key.keys.mappings.n.tree.root.children.0.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.0.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.0.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.0.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.0.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.0.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.0.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.0.prefix_i +string/which-key.keys.mappings.n.tree.root.children.d.prefix_n +string/which-key.keys.mappings.n.tree.root.children.d.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.d.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.d.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.d.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.d.mapping.name +boolean/which-key.keys.mappings.n.tree.root.children.d.mapping.preset +boolean/which-key.keys.mappings.n.tree.root.children.d.mapping.group +string/which-key.keys.mappings.n.tree.root.children.d.mapping.label +string/which-key.keys.mappings.n.tree.root.children.d.mapping.prefix +boolean/which-key.keys.mappings.n.tree.root.children.d.mapping.opts.silent +boolean/which-key.keys.mappings.n.tree.root.children.d.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.d.children.a.prefix_n +string/which-key.keys.mappings.n.tree.root.children.d.children.a.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.d.children.a.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.d.children.a.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.d.children.a.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.d.children.a.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children.d.children.a.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.d.children.a.mapping.name +boolean/which-key.keys.mappings.n.tree.root.children.d.children.a.mapping.preset +boolean/which-key.keys.mappings.n.tree.root.children.d.children.a.mapping.group +string/which-key.keys.mappings.n.tree.root.children.d.children.a.mapping.label +string/which-key.keys.mappings.n.tree.root.children.d.children.a.mapping.mode +boolean/which-key.keys.mappings.n.tree.root.children.d.children.a.mapping.opts.silent +boolean/which-key.keys.mappings.n.tree.root.children.d.children.a.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.d.children.a.prefix_i +string/which-key.keys.mappings.n.tree.root.children.d.children.i.prefix_n +string/which-key.keys.mappings.n.tree.root.children.d.children.i.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.d.children.i.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.d.children.i.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.d.children.i.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.d.children.i.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children.d.children.i.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.d.children.i.mapping.name +boolean/which-key.keys.mappings.n.tree.root.children.d.children.i.mapping.preset +boolean/which-key.keys.mappings.n.tree.root.children.d.children.i.mapping.group +string/which-key.keys.mappings.n.tree.root.children.d.children.i.mapping.label +string/which-key.keys.mappings.n.tree.root.children.d.children.i.mapping.mode +boolean/which-key.keys.mappings.n.tree.root.children.d.children.i.mapping.opts.silent +boolean/which-key.keys.mappings.n.tree.root.children.d.children.i.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.d.children.i.prefix_i +string/which-key.keys.mappings.n.tree.root.children.d.prefix_i +string/which-key.keys.mappings.n.tree.root.children.&.prefix_n +string/which-key.keys.mappings.n.tree.root.children.&.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.&.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.&.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.&.mapping.id +string/which-key.keys.mappings.n.tree.root.children.&.mapping.desc +string/which-key.keys.mappings.n.tree.root.children.&.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.&.mapping.cmd +string/which-key.keys.mappings.n.tree.root.children.&.prefix_i +string/which-key.keys.mappings.n.tree.root.children.^.prefix_n +string/which-key.keys.mappings.n.tree.root.children.^.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.^.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.^.mapping.keys.internal.1 +boolean/which-key.keys.mappings.n.tree.root.children.^.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.^.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.^.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.^.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.^.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.^.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.^.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.^.prefix_i +string/which-key.keys.mappings.n.tree.root.children.F.prefix_n +string/which-key.keys.mappings.n.tree.root.children.F.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.F.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.F.mapping.keys.internal.1 +boolean/which-key.keys.mappings.n.tree.root.children.F.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.F.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.F.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.F.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.F.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.F.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.F.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.F.prefix_i +string/which-key.keys.mappings.n.tree.root.children.@.prefix_n +string/which-key.keys.mappings.n.tree.root.children.@.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.@.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.@.mapping.keys.internal.1 +boolean/which-key.keys.mappings.n.tree.root.children.@.mapping.group +string/which-key.keys.mappings.n.tree.root.children.@.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.@.mapping.plugin +string/which-key.keys.mappings.n.tree.root.children.@.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.@.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.@.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.@.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.@.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.@.children.d.prefix_n +string/which-key.keys.mappings.n.tree.root.children.@.children.d.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.@.children.d.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.@.children.d.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.@.children.d.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.@.children.d.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children.@.children.d.mapping.value +string/which-key.keys.mappings.n.tree.root.children.@.children.d.mapping.label +string/which-key.keys.mappings.n.tree.root.children.@.children.d.mapping.key +string/which-key.keys.mappings.n.tree.root.children.@.children.d.mapping.prefix +number/which-key.keys.mappings.n.tree.root.children.@.children.d.mapping.order +string/which-key.keys.mappings.n.tree.root.children.@.children.d.prefix_i +string/which-key.keys.mappings.n.tree.root.children.@.children.o.prefix_n +string/which-key.keys.mappings.n.tree.root.children.@.children.o.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.@.children.o.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.@.children.o.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.@.children.o.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.@.children.o.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children.@.children.o.mapping.value +string/which-key.keys.mappings.n.tree.root.children.@.children.o.mapping.label +string/which-key.keys.mappings.n.tree.root.children.@.children.o.mapping.key +string/which-key.keys.mappings.n.tree.root.children.@.children.o.mapping.prefix +number/which-key.keys.mappings.n.tree.root.children.@.children.o.mapping.order +string/which-key.keys.mappings.n.tree.root.children.@.children.o.prefix_i +string/which-key.keys.mappings.n.tree.root.children.@.children.4.prefix_n +string/which-key.keys.mappings.n.tree.root.children.@.children.4.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.@.children.4.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.@.children.4.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.@.children.4.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.@.children.4.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children.@.children.4.mapping.value +string/which-key.keys.mappings.n.tree.root.children.@.children.4.mapping.label +string/which-key.keys.mappings.n.tree.root.children.@.children.4.mapping.key +string/which-key.keys.mappings.n.tree.root.children.@.children.4.mapping.prefix +number/which-key.keys.mappings.n.tree.root.children.@.children.4.mapping.order +string/which-key.keys.mappings.n.tree.root.children.@.children.4.prefix_i +string/which-key.keys.mappings.n.tree.root.children.@.children.5.prefix_n +string/which-key.keys.mappings.n.tree.root.children.@.children.5.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.@.children.5.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.@.children.5.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.@.children.5.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.@.children.5.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children.@.children.5.mapping.value +string/which-key.keys.mappings.n.tree.root.children.@.children.5.mapping.label +string/which-key.keys.mappings.n.tree.root.children.@.children.5.mapping.key +string/which-key.keys.mappings.n.tree.root.children.@.children.5.mapping.prefix +number/which-key.keys.mappings.n.tree.root.children.@.children.5.mapping.order +string/which-key.keys.mappings.n.tree.root.children.@.children.5.prefix_i +string/which-key.keys.mappings.n.tree.root.children.@.children.*.prefix_n +string/which-key.keys.mappings.n.tree.root.children.@.children.*.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.@.children.*.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.@.children.*.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.@.children.*.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.@.children.*.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children.@.children.*.mapping.value +string/which-key.keys.mappings.n.tree.root.children.@.children.*.mapping.label +string/which-key.keys.mappings.n.tree.root.children.@.children.*.mapping.key +string/which-key.keys.mappings.n.tree.root.children.@.children.*.mapping.prefix +number/which-key.keys.mappings.n.tree.root.children.@.children.*.mapping.order +string/which-key.keys.mappings.n.tree.root.children.@.children.*.prefix_i +string/which-key.keys.mappings.n.tree.root.children.@.children.a.prefix_n +string/which-key.keys.mappings.n.tree.root.children.@.children.a.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.@.children.a.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.@.children.a.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.@.children.a.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.@.children.a.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children.@.children.a.mapping.value +string/which-key.keys.mappings.n.tree.root.children.@.children.a.mapping.label +string/which-key.keys.mappings.n.tree.root.children.@.children.a.mapping.key +string/which-key.keys.mappings.n.tree.root.children.@.children.a.mapping.prefix +number/which-key.keys.mappings.n.tree.root.children.@.children.a.mapping.order +string/which-key.keys.mappings.n.tree.root.children.@.children.a.prefix_i +string/which-key.keys.mappings.n.tree.root.children.@.children.7.prefix_n +string/which-key.keys.mappings.n.tree.root.children.@.children.7.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.@.children.7.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.@.children.7.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.@.children.7.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.@.children.7.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children.@.children.7.mapping.value +string/which-key.keys.mappings.n.tree.root.children.@.children.7.mapping.label +string/which-key.keys.mappings.n.tree.root.children.@.children.7.mapping.key +string/which-key.keys.mappings.n.tree.root.children.@.children.7.mapping.prefix +number/which-key.keys.mappings.n.tree.root.children.@.children.7.mapping.order +string/which-key.keys.mappings.n.tree.root.children.@.children.7.prefix_i +string/which-key.keys.mappings.n.tree.root.children.@.children.8.prefix_n +string/which-key.keys.mappings.n.tree.root.children.@.children.8.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.@.children.8.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.@.children.8.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.@.children.8.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.@.children.8.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children.@.children.8.mapping.value +string/which-key.keys.mappings.n.tree.root.children.@.children.8.mapping.label +string/which-key.keys.mappings.n.tree.root.children.@.children.8.mapping.key +string/which-key.keys.mappings.n.tree.root.children.@.children.8.mapping.prefix +number/which-key.keys.mappings.n.tree.root.children.@.children.8.mapping.order +string/which-key.keys.mappings.n.tree.root.children.@.children.8.prefix_i +string/which-key.keys.mappings.n.tree.root.children.@.children.2.prefix_n +string/which-key.keys.mappings.n.tree.root.children.@.children.2.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.@.children.2.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.@.children.2.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.@.children.2.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.@.children.2.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children.@.children.2.mapping.value +string/which-key.keys.mappings.n.tree.root.children.@.children.2.mapping.label +string/which-key.keys.mappings.n.tree.root.children.@.children.2.mapping.key +string/which-key.keys.mappings.n.tree.root.children.@.children.2.mapping.prefix +number/which-key.keys.mappings.n.tree.root.children.@.children.2.mapping.order +string/which-key.keys.mappings.n.tree.root.children.@.children.2.prefix_i +string/which-key.keys.mappings.n.tree.root.children.@.children.i.prefix_n +string/which-key.keys.mappings.n.tree.root.children.@.children.i.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.@.children.i.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.@.children.i.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.@.children.i.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.@.children.i.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children.@.children.i.mapping.value +string/which-key.keys.mappings.n.tree.root.children.@.children.i.mapping.label +string/which-key.keys.mappings.n.tree.root.children.@.children.i.mapping.key +string/which-key.keys.mappings.n.tree.root.children.@.children.i.mapping.prefix +number/which-key.keys.mappings.n.tree.root.children.@.children.i.mapping.order +string/which-key.keys.mappings.n.tree.root.children.@.children.i.prefix_i +string/which-key.keys.mappings.n.tree.root.children.@.children.9.prefix_n +string/which-key.keys.mappings.n.tree.root.children.@.children.9.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.@.children.9.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.@.children.9.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.@.children.9.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.@.children.9.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children.@.children.9.mapping.value +string/which-key.keys.mappings.n.tree.root.children.@.children.9.mapping.label +string/which-key.keys.mappings.n.tree.root.children.@.children.9.mapping.key +string/which-key.keys.mappings.n.tree.root.children.@.children.9.mapping.prefix +number/which-key.keys.mappings.n.tree.root.children.@.children.9.mapping.order +string/which-key.keys.mappings.n.tree.root.children.@.children.9.prefix_i +string/which-key.keys.mappings.n.tree.root.children.@.children.6.prefix_n +string/which-key.keys.mappings.n.tree.root.children.@.children.6.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.@.children.6.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.@.children.6.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.@.children.6.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.@.children.6.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children.@.children.6.mapping.value +string/which-key.keys.mappings.n.tree.root.children.@.children.6.mapping.label +string/which-key.keys.mappings.n.tree.root.children.@.children.6.mapping.key +string/which-key.keys.mappings.n.tree.root.children.@.children.6.mapping.prefix +number/which-key.keys.mappings.n.tree.root.children.@.children.6.mapping.order +string/which-key.keys.mappings.n.tree.root.children.@.children.6.prefix_i +string/which-key.keys.mappings.n.tree.root.children.@.children.+.prefix_n +string/which-key.keys.mappings.n.tree.root.children.@.children.+.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.@.children.+.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.@.children.+.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.@.children.+.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.@.children.+.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children.@.children.+.mapping.value +string/which-key.keys.mappings.n.tree.root.children.@.children.+.mapping.label +string/which-key.keys.mappings.n.tree.root.children.@.children.+.mapping.key +string/which-key.keys.mappings.n.tree.root.children.@.children.+.mapping.prefix +number/which-key.keys.mappings.n.tree.root.children.@.children.+.mapping.order +string/which-key.keys.mappings.n.tree.root.children.@.children.+.prefix_i +string/which-key.keys.mappings.n.tree.root.children.@.children.b.prefix_n +string/which-key.keys.mappings.n.tree.root.children.@.children.b.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.@.children.b.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.@.children.b.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.@.children.b.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.@.children.b.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children.@.children.b.mapping.value +string/which-key.keys.mappings.n.tree.root.children.@.children.b.mapping.label +string/which-key.keys.mappings.n.tree.root.children.@.children.b.mapping.key +string/which-key.keys.mappings.n.tree.root.children.@.children.b.mapping.prefix +number/which-key.keys.mappings.n.tree.root.children.@.children.b.mapping.order +string/which-key.keys.mappings.n.tree.root.children.@.children.b.prefix_i +string/which-key.keys.mappings.n.tree.root.children.@.children.k.prefix_n +string/which-key.keys.mappings.n.tree.root.children.@.children.k.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.@.children.k.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.@.children.k.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.@.children.k.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.@.children.k.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children.@.children.k.mapping.value +string/which-key.keys.mappings.n.tree.root.children.@.children.k.mapping.label +string/which-key.keys.mappings.n.tree.root.children.@.children.k.mapping.key +string/which-key.keys.mappings.n.tree.root.children.@.children.k.mapping.prefix +number/which-key.keys.mappings.n.tree.root.children.@.children.k.mapping.order +string/which-key.keys.mappings.n.tree.root.children.@.children.k.prefix_i +string/which-key.keys.mappings.n.tree.root.children.@.children.l.prefix_n +string/which-key.keys.mappings.n.tree.root.children.@.children.l.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.@.children.l.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.@.children.l.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.@.children.l.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.@.children.l.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children.@.children.l.mapping.value +string/which-key.keys.mappings.n.tree.root.children.@.children.l.mapping.label +string/which-key.keys.mappings.n.tree.root.children.@.children.l.mapping.key +string/which-key.keys.mappings.n.tree.root.children.@.children.l.mapping.prefix +number/which-key.keys.mappings.n.tree.root.children.@.children.l.mapping.order +string/which-key.keys.mappings.n.tree.root.children.@.children.l.prefix_i +string/which-key.keys.mappings.n.tree.root.children.@.children.1.prefix_n +string/which-key.keys.mappings.n.tree.root.children.@.children.1.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.@.children.1.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.@.children.1.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.@.children.1.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.@.children.1.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children.@.children.1.mapping.value +string/which-key.keys.mappings.n.tree.root.children.@.children.1.mapping.label +string/which-key.keys.mappings.n.tree.root.children.@.children.1.mapping.key +string/which-key.keys.mappings.n.tree.root.children.@.children.1.mapping.prefix +number/which-key.keys.mappings.n.tree.root.children.@.children.1.mapping.order +string/which-key.keys.mappings.n.tree.root.children.@.children.1.prefix_i +string/which-key.keys.mappings.n.tree.root.children.@.children...prefix_n +string/which-key.keys.mappings.n.tree.root.children.@.children...mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.@.children...mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.@.children...mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.@.children...mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.@.children...mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children.@.children...mapping.value +string/which-key.keys.mappings.n.tree.root.children.@.children...mapping.label +string/which-key.keys.mappings.n.tree.root.children.@.children...mapping.key +string/which-key.keys.mappings.n.tree.root.children.@.children...mapping.prefix +number/which-key.keys.mappings.n.tree.root.children.@.children...mapping.order +string/which-key.keys.mappings.n.tree.root.children.@.children...prefix_i +string/which-key.keys.mappings.n.tree.root.children.@.children.-.prefix_n +string/which-key.keys.mappings.n.tree.root.children.@.children.-.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.@.children.-.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.@.children.-.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.@.children.-.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.@.children.-.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children.@.children.-.mapping.value +string/which-key.keys.mappings.n.tree.root.children.@.children.-.mapping.label +string/which-key.keys.mappings.n.tree.root.children.@.children.-.mapping.key +string/which-key.keys.mappings.n.tree.root.children.@.children.-.mapping.prefix +number/which-key.keys.mappings.n.tree.root.children.@.children.-.mapping.order +string/which-key.keys.mappings.n.tree.root.children.@.children.-.prefix_i +string/which-key.keys.mappings.n.tree.root.children.@.children.0.prefix_n +string/which-key.keys.mappings.n.tree.root.children.@.children.0.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.@.children.0.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.@.children.0.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.@.children.0.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.@.children.0.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children.@.children.0.mapping.value +string/which-key.keys.mappings.n.tree.root.children.@.children.0.mapping.label +string/which-key.keys.mappings.n.tree.root.children.@.children.0.mapping.key +string/which-key.keys.mappings.n.tree.root.children.@.children.0.mapping.prefix +number/which-key.keys.mappings.n.tree.root.children.@.children.0.mapping.order +string/which-key.keys.mappings.n.tree.root.children.@.children.0.prefix_i +string/which-key.keys.mappings.n.tree.root.children.@.children.y.prefix_n +string/which-key.keys.mappings.n.tree.root.children.@.children.y.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.@.children.y.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.@.children.y.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.@.children.y.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.@.children.y.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children.@.children.y.mapping.value +string/which-key.keys.mappings.n.tree.root.children.@.children.y.mapping.label +string/which-key.keys.mappings.n.tree.root.children.@.children.y.mapping.key +string/which-key.keys.mappings.n.tree.root.children.@.children.y.mapping.prefix +number/which-key.keys.mappings.n.tree.root.children.@.children.y.mapping.order +string/which-key.keys.mappings.n.tree.root.children.@.children.y.prefix_i +string/which-key.keys.mappings.n.tree.root.children.@.children.%.prefix_n +string/which-key.keys.mappings.n.tree.root.children.@.children.%.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.@.children.%.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.@.children.%.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.@.children.%.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.@.children.%.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children.@.children.%.mapping.value +string/which-key.keys.mappings.n.tree.root.children.@.children.%.mapping.label +string/which-key.keys.mappings.n.tree.root.children.@.children.%.mapping.key +string/which-key.keys.mappings.n.tree.root.children.@.children.%.mapping.prefix +number/which-key.keys.mappings.n.tree.root.children.@.children.%.mapping.order +string/which-key.keys.mappings.n.tree.root.children.@.children.%.prefix_i +string/which-key.keys.mappings.n.tree.root.children.@.children.q.prefix_n +string/which-key.keys.mappings.n.tree.root.children.@.children.q.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.@.children.q.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.@.children.q.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.@.children.q.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.@.children.q.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children.@.children.q.mapping.value +string/which-key.keys.mappings.n.tree.root.children.@.children.q.mapping.label +string/which-key.keys.mappings.n.tree.root.children.@.children.q.mapping.key +string/which-key.keys.mappings.n.tree.root.children.@.children.q.mapping.prefix +number/which-key.keys.mappings.n.tree.root.children.@.children.q.mapping.order +string/which-key.keys.mappings.n.tree.root.children.@.children.q.prefix_i +string/which-key.keys.mappings.n.tree.root.children.@.children.w.prefix_n +string/which-key.keys.mappings.n.tree.root.children.@.children.w.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.@.children.w.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.@.children.w.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.@.children.w.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.@.children.w.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children.@.children.w.mapping.value +string/which-key.keys.mappings.n.tree.root.children.@.children.w.mapping.label +string/which-key.keys.mappings.n.tree.root.children.@.children.w.mapping.key +string/which-key.keys.mappings.n.tree.root.children.@.children.w.mapping.prefix +number/which-key.keys.mappings.n.tree.root.children.@.children.w.mapping.order +string/which-key.keys.mappings.n.tree.root.children.@.children.w.prefix_i +string/which-key.keys.mappings.n.tree.root.children.@.children.g.prefix_n +string/which-key.keys.mappings.n.tree.root.children.@.children.g.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.@.children.g.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.@.children.g.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.@.children.g.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.@.children.g.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children.@.children.g.mapping.value +string/which-key.keys.mappings.n.tree.root.children.@.children.g.mapping.label +string/which-key.keys.mappings.n.tree.root.children.@.children.g.mapping.key +string/which-key.keys.mappings.n.tree.root.children.@.children.g.mapping.prefix +number/which-key.keys.mappings.n.tree.root.children.@.children.g.mapping.order +string/which-key.keys.mappings.n.tree.root.children.@.children.g.prefix_i +string/which-key.keys.mappings.n.tree.root.children.@.children.".prefix_n +string/which-key.keys.mappings.n.tree.root.children.@.children.".mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.@.children.".mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.@.children.".mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.@.children.".mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.@.children.".mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children.@.children.".mapping.value +string/which-key.keys.mappings.n.tree.root.children.@.children.".mapping.label +string/which-key.keys.mappings.n.tree.root.children.@.children.".mapping.key +string/which-key.keys.mappings.n.tree.root.children.@.children.".mapping.prefix +number/which-key.keys.mappings.n.tree.root.children.@.children.".mapping.order +string/which-key.keys.mappings.n.tree.root.children.@.children.".prefix_i +string/which-key.keys.mappings.n.tree.root.children.@.children./.prefix_n +string/which-key.keys.mappings.n.tree.root.children.@.children./.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.@.children./.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.@.children./.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.@.children./.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.@.children./.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children.@.children./.mapping.value +string/which-key.keys.mappings.n.tree.root.children.@.children./.mapping.label +string/which-key.keys.mappings.n.tree.root.children.@.children./.mapping.key +string/which-key.keys.mappings.n.tree.root.children.@.children./.mapping.prefix +number/which-key.keys.mappings.n.tree.root.children.@.children./.mapping.order +string/which-key.keys.mappings.n.tree.root.children.@.children./.prefix_i +string/which-key.keys.mappings.n.tree.root.children.@.children.3.prefix_n +string/which-key.keys.mappings.n.tree.root.children.@.children.3.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.@.children.3.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.@.children.3.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.@.children.3.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.@.children.3.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children.@.children.3.mapping.value +string/which-key.keys.mappings.n.tree.root.children.@.children.3.mapping.label +string/which-key.keys.mappings.n.tree.root.children.@.children.3.mapping.key +string/which-key.keys.mappings.n.tree.root.children.@.children.3.mapping.prefix +number/which-key.keys.mappings.n.tree.root.children.@.children.3.mapping.order +string/which-key.keys.mappings.n.tree.root.children.@.children.3.prefix_i +string/which-key.keys.mappings.n.tree.root.children.@.children.:.prefix_n +string/which-key.keys.mappings.n.tree.root.children.@.children.:.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.@.children.:.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.@.children.:.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.@.children.:.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.@.children.:.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children.@.children.:.mapping.value +string/which-key.keys.mappings.n.tree.root.children.@.children.:.mapping.label +string/which-key.keys.mappings.n.tree.root.children.@.children.:.mapping.key +string/which-key.keys.mappings.n.tree.root.children.@.children.:.mapping.prefix +number/which-key.keys.mappings.n.tree.root.children.@.children.:.mapping.order +string/which-key.keys.mappings.n.tree.root.children.@.children.:.prefix_i +string/which-key.keys.mappings.n.tree.root.children.@.children.j.prefix_n +string/which-key.keys.mappings.n.tree.root.children.@.children.j.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.@.children.j.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.@.children.j.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.@.children.j.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.@.children.j.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children.@.children.j.mapping.value +string/which-key.keys.mappings.n.tree.root.children.@.children.j.mapping.label +string/which-key.keys.mappings.n.tree.root.children.@.children.j.mapping.key +string/which-key.keys.mappings.n.tree.root.children.@.children.j.mapping.prefix +number/which-key.keys.mappings.n.tree.root.children.@.children.j.mapping.order +string/which-key.keys.mappings.n.tree.root.children.@.children.j.prefix_i +string/which-key.keys.mappings.n.tree.root.children.@.prefix_i +string/which-key.keys.mappings.n.tree.root.children.^H.prefix_n +string/which-key.keys.mappings.n.tree.root.children.^H.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.^H.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.^H.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.^H.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.^H.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.^H.mapping.desc +string/which-key.keys.mappings.n.tree.root.children.^H.mapping.id +string/which-key.keys.mappings.n.tree.root.children.^H.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.^H.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.^H.mapping.opts.desc +function/0/which-key.keys.mappings.n.tree.root.children.^H.mapping.opts.callback +boolean/which-key.keys.mappings.n.tree.root.children.^H.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.^H.mapping.cmd +string/which-key.keys.mappings.n.tree.root.children.^H.prefix_i +string/which-key.keys.mappings.n.tree.root.children.K.prefix_n +string/which-key.keys.mappings.n.tree.root.children.K.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.K.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.K.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.K.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.K.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.K.mapping.desc +string/which-key.keys.mappings.n.tree.root.children.K.mapping.id +string/which-key.keys.mappings.n.tree.root.children.K.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.K.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.K.mapping.opts.desc +function/0/which-key.keys.mappings.n.tree.root.children.K.mapping.opts.callback +boolean/which-key.keys.mappings.n.tree.root.children.K.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.K.mapping.cmd +string/which-key.keys.mappings.n.tree.root.children.K.prefix_i +string/which-key.keys.mappings.n.tree.root.children.}.prefix_n +string/which-key.keys.mappings.n.tree.root.children.}.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.}.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.}.mapping.keys.internal.1 +boolean/which-key.keys.mappings.n.tree.root.children.}.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.}.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.}.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.}.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.}.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.}.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.}.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.}.prefix_i +string/which-key.keys.mappings.n.tree.root.children.^N.prefix_n +string/which-key.keys.mappings.n.tree.root.children.^N.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.^N.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.^N.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.^N.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.^N.mapping.id +string/which-key.keys.mappings.n.tree.root.children.^N.prefix_i +string/which-key.keys.mappings.n.tree.root.children.h.prefix_n +string/which-key.keys.mappings.n.tree.root.children.h.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.h.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.h.mapping.keys.internal.1 +boolean/which-key.keys.mappings.n.tree.root.children.h.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.h.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.h.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.h.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.h.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.h.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.h.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.h.prefix_i +string/which-key.keys.mappings.n.tree.root.children.f.prefix_n +string/which-key.keys.mappings.n.tree.root.children.f.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.f.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.f.mapping.keys.internal.1 +boolean/which-key.keys.mappings.n.tree.root.children.f.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.f.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.f.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.f.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.f.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.f.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.f.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.f.prefix_i +string/which-key.keys.mappings.n.tree.root.children.{.prefix_n +string/which-key.keys.mappings.n.tree.root.children.{.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.{.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.{.mapping.keys.internal.1 +boolean/which-key.keys.mappings.n.tree.root.children.{.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.{.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.{.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.{.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.{.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.{.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.{.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.{.prefix_i +string/which-key.keys.mappings.n.tree.root.children.Y.prefix_n +string/which-key.keys.mappings.n.tree.root.children.Y.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.Y.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.Y.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.Y.mapping.id +string/which-key.keys.mappings.n.tree.root.children.Y.mapping.desc +string/which-key.keys.mappings.n.tree.root.children.Y.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.Y.mapping.cmd +string/which-key.keys.mappings.n.tree.root.children.Y.prefix_i +string/which-key.keys.mappings.n.tree.root.children.k.prefix_n +string/which-key.keys.mappings.n.tree.root.children.k.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.k.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.k.mapping.keys.internal.1 +boolean/which-key.keys.mappings.n.tree.root.children.k.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.k.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.k.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.k.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.k.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.k.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.k.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.k.prefix_i +string/which-key.keys.mappings.n.tree.root.children.^W.prefix_n +string/which-key.keys.mappings.n.tree.root.children.^W.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.^W.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.^W.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.^W.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.^W.mapping.name +boolean/which-key.keys.mappings.n.tree.root.children.^W.mapping.preset +boolean/which-key.keys.mappings.n.tree.root.children.^W.mapping.group +string/which-key.keys.mappings.n.tree.root.children.^W.mapping.label +string/which-key.keys.mappings.n.tree.root.children.^W.mapping.mode +boolean/which-key.keys.mappings.n.tree.root.children.^W.mapping.opts.silent +boolean/which-key.keys.mappings.n.tree.root.children.^W.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.^W.children.j.prefix_n +string/which-key.keys.mappings.n.tree.root.children.^W.children.j.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.^W.children.j.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.^W.children.j.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.^W.children.j.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.^W.children.j.mapping.keys.internal.2 +boolean/which-key.keys.mappings.n.tree.root.children.^W.children.j.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.^W.children.j.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.^W.children.j.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.^W.children.j.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.^W.children.j.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.^W.children.j.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.^W.children.j.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.^W.children.j.prefix_i +string/which-key.keys.mappings.n.tree.root.children.^W.children.x.prefix_n +string/which-key.keys.mappings.n.tree.root.children.^W.children.x.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.^W.children.x.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.^W.children.x.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.^W.children.x.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.^W.children.x.mapping.keys.internal.2 +boolean/which-key.keys.mappings.n.tree.root.children.^W.children.x.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.^W.children.x.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.^W.children.x.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.^W.children.x.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.^W.children.x.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.^W.children.x.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.^W.children.x.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.^W.children.x.prefix_i +string/which-key.keys.mappings.n.tree.root.children.^W.children.<.prefix_n +string/which-key.keys.mappings.n.tree.root.children.^W.children.<.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.^W.children.<.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.^W.children.<.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.^W.children.<.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.^W.children.<.mapping.keys.internal.2 +boolean/which-key.keys.mappings.n.tree.root.children.^W.children.<.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.^W.children.<.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.^W.children.<.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.^W.children.<.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.^W.children.<.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.^W.children.<.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.^W.children.<.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.^W.children.<.prefix_i +string/which-key.keys.mappings.n.tree.root.children.^W.children.>.prefix_n +string/which-key.keys.mappings.n.tree.root.children.^W.children.>.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.^W.children.>.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.^W.children.>.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.^W.children.>.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.^W.children.>.mapping.keys.internal.2 +boolean/which-key.keys.mappings.n.tree.root.children.^W.children.>.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.^W.children.>.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.^W.children.>.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.^W.children.>.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.^W.children.>.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.^W.children.>.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.^W.children.>.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.^W.children.>.prefix_i +string/which-key.keys.mappings.n.tree.root.children.^W.children.=.prefix_n +string/which-key.keys.mappings.n.tree.root.children.^W.children.=.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.^W.children.=.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.^W.children.=.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.^W.children.=.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.^W.children.=.mapping.keys.internal.2 +boolean/which-key.keys.mappings.n.tree.root.children.^W.children.=.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.^W.children.=.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.^W.children.=.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.^W.children.=.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.^W.children.=.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.^W.children.=.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.^W.children.=.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.^W.children.=.prefix_i +string/which-key.keys.mappings.n.tree.root.children.^W.children.s.prefix_n +string/which-key.keys.mappings.n.tree.root.children.^W.children.s.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.^W.children.s.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.^W.children.s.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.^W.children.s.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.^W.children.s.mapping.keys.internal.2 +boolean/which-key.keys.mappings.n.tree.root.children.^W.children.s.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.^W.children.s.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.^W.children.s.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.^W.children.s.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.^W.children.s.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.^W.children.s.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.^W.children.s.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.^W.children.s.prefix_i +string/which-key.keys.mappings.n.tree.root.children.^W.children.|.prefix_n +string/which-key.keys.mappings.n.tree.root.children.^W.children.|.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.^W.children.|.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.^W.children.|.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.^W.children.|.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.^W.children.|.mapping.keys.internal.2 +boolean/which-key.keys.mappings.n.tree.root.children.^W.children.|.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.^W.children.|.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.^W.children.|.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.^W.children.|.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.^W.children.|.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.^W.children.|.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.^W.children.|.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.^W.children.|.prefix_i +string/which-key.keys.mappings.n.tree.root.children.^W.children.-.prefix_n +string/which-key.keys.mappings.n.tree.root.children.^W.children.-.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.^W.children.-.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.^W.children.-.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.^W.children.-.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.^W.children.-.mapping.keys.internal.2 +boolean/which-key.keys.mappings.n.tree.root.children.^W.children.-.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.^W.children.-.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.^W.children.-.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.^W.children.-.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.^W.children.-.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.^W.children.-.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.^W.children.-.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.^W.children.-.prefix_i +string/which-key.keys.mappings.n.tree.root.children.^W.children._.prefix_n +string/which-key.keys.mappings.n.tree.root.children.^W.children._.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.^W.children._.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.^W.children._.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.^W.children._.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.^W.children._.mapping.keys.internal.2 +boolean/which-key.keys.mappings.n.tree.root.children.^W.children._.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.^W.children._.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.^W.children._.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.^W.children._.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.^W.children._.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.^W.children._.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.^W.children._.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.^W.children._.prefix_i +string/which-key.keys.mappings.n.tree.root.children.^W.children.l.prefix_n +string/which-key.keys.mappings.n.tree.root.children.^W.children.l.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.^W.children.l.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.^W.children.l.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.^W.children.l.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.^W.children.l.mapping.keys.internal.2 +boolean/which-key.keys.mappings.n.tree.root.children.^W.children.l.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.^W.children.l.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.^W.children.l.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.^W.children.l.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.^W.children.l.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.^W.children.l.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.^W.children.l.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.^W.children.l.prefix_i +string/which-key.keys.mappings.n.tree.root.children.^W.children.w.prefix_n +string/which-key.keys.mappings.n.tree.root.children.^W.children.w.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.^W.children.w.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.^W.children.w.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.^W.children.w.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.^W.children.w.mapping.keys.internal.2 +boolean/which-key.keys.mappings.n.tree.root.children.^W.children.w.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.^W.children.w.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.^W.children.w.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.^W.children.w.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.^W.children.w.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.^W.children.w.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.^W.children.w.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.^W.children.w.prefix_i +string/which-key.keys.mappings.n.tree.root.children.^W.children.T.prefix_n +string/which-key.keys.mappings.n.tree.root.children.^W.children.T.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.^W.children.T.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.^W.children.T.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.^W.children.T.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.^W.children.T.mapping.keys.internal.2 +boolean/which-key.keys.mappings.n.tree.root.children.^W.children.T.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.^W.children.T.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.^W.children.T.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.^W.children.T.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.^W.children.T.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.^W.children.T.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.^W.children.T.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.^W.children.T.prefix_i +string/which-key.keys.mappings.n.tree.root.children.^W.children.h.prefix_n +string/which-key.keys.mappings.n.tree.root.children.^W.children.h.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.^W.children.h.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.^W.children.h.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.^W.children.h.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.^W.children.h.mapping.keys.internal.2 +boolean/which-key.keys.mappings.n.tree.root.children.^W.children.h.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.^W.children.h.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.^W.children.h.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.^W.children.h.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.^W.children.h.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.^W.children.h.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.^W.children.h.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.^W.children.h.prefix_i +string/which-key.keys.mappings.n.tree.root.children.^W.children.v.prefix_n +string/which-key.keys.mappings.n.tree.root.children.^W.children.v.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.^W.children.v.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.^W.children.v.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.^W.children.v.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.^W.children.v.mapping.keys.internal.2 +boolean/which-key.keys.mappings.n.tree.root.children.^W.children.v.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.^W.children.v.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.^W.children.v.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.^W.children.v.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.^W.children.v.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.^W.children.v.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.^W.children.v.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.^W.children.v.prefix_i +string/which-key.keys.mappings.n.tree.root.children.^W.children.k.prefix_n +string/which-key.keys.mappings.n.tree.root.children.^W.children.k.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.^W.children.k.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.^W.children.k.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.^W.children.k.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.^W.children.k.mapping.keys.internal.2 +boolean/which-key.keys.mappings.n.tree.root.children.^W.children.k.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.^W.children.k.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.^W.children.k.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.^W.children.k.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.^W.children.k.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.^W.children.k.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.^W.children.k.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.^W.children.k.prefix_i +string/which-key.keys.mappings.n.tree.root.children.^W.children.q.prefix_n +string/which-key.keys.mappings.n.tree.root.children.^W.children.q.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.^W.children.q.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.^W.children.q.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.^W.children.q.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.^W.children.q.mapping.keys.internal.2 +boolean/which-key.keys.mappings.n.tree.root.children.^W.children.q.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.^W.children.q.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.^W.children.q.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.^W.children.q.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.^W.children.q.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.^W.children.q.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.^W.children.q.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.^W.children.q.prefix_i +string/which-key.keys.mappings.n.tree.root.children.^W.children.+.prefix_n +string/which-key.keys.mappings.n.tree.root.children.^W.children.+.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.^W.children.+.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.^W.children.+.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.^W.children.+.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.^W.children.+.mapping.keys.internal.2 +boolean/which-key.keys.mappings.n.tree.root.children.^W.children.+.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.^W.children.+.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.^W.children.+.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.^W.children.+.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.^W.children.+.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.^W.children.+.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.^W.children.+.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.^W.children.+.prefix_i +string/which-key.keys.mappings.n.tree.root.children.^W.prefix_i +string/which-key.keys.mappings.n.tree.root.children.w.prefix_n +string/which-key.keys.mappings.n.tree.root.children.w.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.w.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.w.mapping.keys.internal.1 +boolean/which-key.keys.mappings.n.tree.root.children.w.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.w.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.w.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.w.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.w.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.w.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.w.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.w.prefix_i +string/which-key.keys.mappings.n.tree.root.children.].prefix_n +string/which-key.keys.mappings.n.tree.root.children.].mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.].mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.].mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.].mapping.prefix +boolean/which-key.keys.mappings.n.tree.root.children.].mapping.group +string/which-key.keys.mappings.n.tree.root.children.].children.d.prefix_n +string/which-key.keys.mappings.n.tree.root.children.].children.d.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.].children.d.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.].children.d.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.].children.d.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.].children.d.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children.].children.d.mapping.prefix +boolean/which-key.keys.mappings.n.tree.root.children.].children.d.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.].children.d.mapping.opts.desc +function/1/which-key.keys.mappings.n.tree.root.children.].children.d.mapping.opts.callback +boolean/which-key.keys.mappings.n.tree.root.children.].children.d.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.].children.d.mapping.label +string/which-key.keys.mappings.n.tree.root.children.].children.d.mapping.id +string/which-key.keys.mappings.n.tree.root.children.].children.d.mapping.desc +string/which-key.keys.mappings.n.tree.root.children.].children.d.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.].children.d.mapping.cmd +string/which-key.keys.mappings.n.tree.root.children.].children.d.prefix_i +string/which-key.keys.mappings.n.tree.root.children.].children.s.prefix_n +string/which-key.keys.mappings.n.tree.root.children.].children.s.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.].children.s.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.].children.s.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.].children.s.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.].children.s.mapping.keys.internal.2 +boolean/which-key.keys.mappings.n.tree.root.children.].children.s.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.].children.s.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.].children.s.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.].children.s.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.].children.s.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.].children.s.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.].children.s.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.].children.s.prefix_i +string/which-key.keys.mappings.n.tree.root.children.].children.(.prefix_n +string/which-key.keys.mappings.n.tree.root.children.].children.(.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.].children.(.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.].children.(.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.].children.(.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.].children.(.mapping.keys.internal.2 +boolean/which-key.keys.mappings.n.tree.root.children.].children.(.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.].children.(.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.].children.(.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.].children.(.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.].children.(.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.].children.(.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.].children.(.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.].children.(.prefix_i +string/which-key.keys.mappings.n.tree.root.children.].children.M.prefix_n +string/which-key.keys.mappings.n.tree.root.children.].children.M.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.].children.M.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.].children.M.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.].children.M.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.].children.M.mapping.keys.internal.2 +boolean/which-key.keys.mappings.n.tree.root.children.].children.M.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.].children.M.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.].children.M.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.].children.M.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.].children.M.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.].children.M.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.].children.M.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.].children.M.prefix_i +string/which-key.keys.mappings.n.tree.root.children.].children.{.prefix_n +string/which-key.keys.mappings.n.tree.root.children.].children.{.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.].children.{.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.].children.{.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.].children.{.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.].children.{.mapping.keys.internal.2 +boolean/which-key.keys.mappings.n.tree.root.children.].children.{.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.].children.{.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.].children.{.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.].children.{.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.].children.{.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.].children.{.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.].children.{.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.].children.{.prefix_i +string/which-key.keys.mappings.n.tree.root.children.].children.<.prefix_n +string/which-key.keys.mappings.n.tree.root.children.].children.<.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.].children.<.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.].children.<.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.].children.<.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.].children.<.mapping.keys.internal.2 +boolean/which-key.keys.mappings.n.tree.root.children.].children.<.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.].children.<.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.].children.<.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.].children.<.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.].children.<.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.].children.<.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.].children.<.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.].children.<.prefix_i +string/which-key.keys.mappings.n.tree.root.children.].children.m.prefix_n +string/which-key.keys.mappings.n.tree.root.children.].children.m.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.].children.m.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.].children.m.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.].children.m.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.].children.m.mapping.keys.internal.2 +boolean/which-key.keys.mappings.n.tree.root.children.].children.m.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.].children.m.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.].children.m.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.].children.m.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.].children.m.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.].children.m.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.].children.m.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.].children.m.prefix_i +string/which-key.keys.mappings.n.tree.root.children.].children.%.prefix_n +string/which-key.keys.mappings.n.tree.root.children.].children.%.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.].children.%.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.].children.%.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.].children.%.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.].children.%.mapping.keys.internal.2 +boolean/which-key.keys.mappings.n.tree.root.children.].children.%.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.].children.%.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.].children.%.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.].children.%.mapping.mode +boolean/which-key.keys.mappings.n.tree.root.children.].children.%.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.].children.%.mapping.id +string/which-key.keys.mappings.n.tree.root.children.].children.%.mapping.label +string/which-key.keys.mappings.n.tree.root.children.].children.%.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.].children.%.mapping.cmd +string/which-key.keys.mappings.n.tree.root.children.].children.%.prefix_i +string/which-key.keys.mappings.n.tree.root.children.].prefix_i +string/which-key.keys.mappings.n.tree.root.children.".prefix_n +string/which-key.keys.mappings.n.tree.root.children.".mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.".mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.".mapping.keys.internal.1 +boolean/which-key.keys.mappings.n.tree.root.children.".mapping.group +string/which-key.keys.mappings.n.tree.root.children.".mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.".mapping.plugin +string/which-key.keys.mappings.n.tree.root.children.".mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.".mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.".mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.".mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.".mapping.mode +string/which-key.keys.mappings.n.tree.root.children.".prefix_i +string/which-key.keys.mappings.n.tree.root.children.e.prefix_n +string/which-key.keys.mappings.n.tree.root.children.e.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.e.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.e.mapping.keys.internal.1 +boolean/which-key.keys.mappings.n.tree.root.children.e.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.e.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.e.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.e.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.e.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.e.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.e.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.e.prefix_i +string/which-key.keys.mappings.n.tree.root.children.$.prefix_n +string/which-key.keys.mappings.n.tree.root.children.$.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.$.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.$.mapping.keys.internal.1 +boolean/which-key.keys.mappings.n.tree.root.children.$.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.$.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.$.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.$.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.$.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.$.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.$.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.$.prefix_i +string/which-key.keys.mappings.n.tree.root.children.%.prefix_n +string/which-key.keys.mappings.n.tree.root.children.%.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.%.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.%.mapping.keys.internal.1 +boolean/which-key.keys.mappings.n.tree.root.children.%.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.%.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.%.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.%.mapping.mode +boolean/which-key.keys.mappings.n.tree.root.children.%.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.%.mapping.id +string/which-key.keys.mappings.n.tree.root.children.%.mapping.label +string/which-key.keys.mappings.n.tree.root.children.%.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.%.mapping.cmd +string/which-key.keys.mappings.n.tree.root.children.%.prefix_i +string/which-key.keys.mappings.n.tree.root.children. .prefix_n +string/which-key.keys.mappings.n.tree.root.children. .mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children. .mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children. .mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children. .mapping.prefix +boolean/which-key.keys.mappings.n.tree.root.children. .mapping.group +string/which-key.keys.mappings.n.tree.root.children. .children.c.prefix_n +string/which-key.keys.mappings.n.tree.root.children. .children.c.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children. .children.c.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children. .children.c.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children. .children.c.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children. .children.c.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children. .children.c.mapping.prefix +boolean/which-key.keys.mappings.n.tree.root.children. .children.c.mapping.group +string/which-key.keys.mappings.n.tree.root.children. .children.c.children.a.prefix_n +string/which-key.keys.mappings.n.tree.root.children. .children.c.children.a.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children. .children.c.children.a.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children. .children.c.children.a.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children. .children.c.children.a.mapping.keys.notation.3 +string/which-key.keys.mappings.n.tree.root.children. .children.c.children.a.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children. .children.c.children.a.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children. .children.c.children.a.mapping.keys.internal.3 +string/which-key.keys.mappings.n.tree.root.children. .children.c.children.a.mapping.mode +string/which-key.keys.mappings.n.tree.root.children. .children.c.children.a.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children. .children.c.children.a.mapping.desc +string/which-key.keys.mappings.n.tree.root.children. .children.c.children.a.mapping.id +string/which-key.keys.mappings.n.tree.root.children. .children.c.children.a.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children. .children.c.children.a.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children. .children.c.children.a.mapping.opts.desc +function/1/which-key.keys.mappings.n.tree.root.children. .children.c.children.a.mapping.opts.callback +boolean/which-key.keys.mappings.n.tree.root.children. .children.c.children.a.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children. .children.c.children.a.mapping.cmd +string/which-key.keys.mappings.n.tree.root.children. .children.c.children.a.prefix_i +string/which-key.keys.mappings.n.tree.root.children. .children.c.prefix_i +string/which-key.keys.mappings.n.tree.root.children. .children.f.prefix_n +string/which-key.keys.mappings.n.tree.root.children. .children.f.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children. .children.f.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children. .children.f.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children. .children.f.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children. .children.f.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children. .children.f.mapping.mode +string/which-key.keys.mappings.n.tree.root.children. .children.f.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children. .children.f.mapping.desc +string/which-key.keys.mappings.n.tree.root.children. .children.f.mapping.id +string/which-key.keys.mappings.n.tree.root.children. .children.f.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children. .children.f.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children. .children.f.mapping.opts.desc +function/0/which-key.keys.mappings.n.tree.root.children. .children.f.mapping.opts.callback +boolean/which-key.keys.mappings.n.tree.root.children. .children.f.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children. .children.f.mapping.cmd +string/which-key.keys.mappings.n.tree.root.children. .children.f.prefix_i +string/which-key.keys.mappings.n.tree.root.children. .children.D.prefix_n +string/which-key.keys.mappings.n.tree.root.children. .children.D.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children. .children.D.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children. .children.D.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children. .children.D.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children. .children.D.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children. .children.D.mapping.mode +string/which-key.keys.mappings.n.tree.root.children. .children.D.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children. .children.D.mapping.desc +string/which-key.keys.mappings.n.tree.root.children. .children.D.mapping.id +string/which-key.keys.mappings.n.tree.root.children. .children.D.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children. .children.D.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children. .children.D.mapping.opts.desc +function/1/which-key.keys.mappings.n.tree.root.children. .children.D.mapping.opts.callback +boolean/which-key.keys.mappings.n.tree.root.children. .children.D.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children. .children.D.mapping.cmd +string/which-key.keys.mappings.n.tree.root.children. .children.D.prefix_i +string/which-key.keys.mappings.n.tree.root.children. .children.q.prefix_n +string/which-key.keys.mappings.n.tree.root.children. .children.q.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children. .children.q.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children. .children.q.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children. .children.q.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children. .children.q.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children. .children.q.mapping.prefix +boolean/which-key.keys.mappings.n.tree.root.children. .children.q.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children. .children.q.mapping.opts.desc +function/1/which-key.keys.mappings.n.tree.root.children. .children.q.mapping.opts.callback +boolean/which-key.keys.mappings.n.tree.root.children. .children.q.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children. .children.q.mapping.label +string/which-key.keys.mappings.n.tree.root.children. .children.q.mapping.id +string/which-key.keys.mappings.n.tree.root.children. .children.q.mapping.desc +string/which-key.keys.mappings.n.tree.root.children. .children.q.mapping.mode +string/which-key.keys.mappings.n.tree.root.children. .children.q.mapping.cmd +string/which-key.keys.mappings.n.tree.root.children. .children.q.prefix_i +string/which-key.keys.mappings.n.tree.root.children. .children./.prefix_n +string/which-key.keys.mappings.n.tree.root.children. .children./.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children. .children./.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children. .children./.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children. .children./.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children. .children./.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children. .children./.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children. .children./.mapping.id +string/which-key.keys.mappings.n.tree.root.children. .children./.prefix_i +string/which-key.keys.mappings.n.tree.root.children. .children.e.prefix_n +string/which-key.keys.mappings.n.tree.root.children. .children.e.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children. .children.e.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children. .children.e.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children. .children.e.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children. .children.e.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children. .children.e.mapping.prefix +boolean/which-key.keys.mappings.n.tree.root.children. .children.e.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children. .children.e.mapping.opts.desc +function/1/which-key.keys.mappings.n.tree.root.children. .children.e.mapping.opts.callback +boolean/which-key.keys.mappings.n.tree.root.children. .children.e.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children. .children.e.mapping.label +string/which-key.keys.mappings.n.tree.root.children. .children.e.mapping.id +string/which-key.keys.mappings.n.tree.root.children. .children.e.mapping.desc +string/which-key.keys.mappings.n.tree.root.children. .children.e.mapping.mode +string/which-key.keys.mappings.n.tree.root.children. .children.e.mapping.cmd +string/which-key.keys.mappings.n.tree.root.children. .children.e.prefix_i +string/which-key.keys.mappings.n.tree.root.children. .children.w.prefix_n +string/which-key.keys.mappings.n.tree.root.children. .children.w.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children. .children.w.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children. .children.w.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children. .children.w.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children. .children.w.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children. .children.w.mapping.prefix +boolean/which-key.keys.mappings.n.tree.root.children. .children.w.mapping.group +string/which-key.keys.mappings.n.tree.root.children. .children.w.children.l.prefix_n +string/which-key.keys.mappings.n.tree.root.children. .children.w.children.l.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children. .children.w.children.l.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children. .children.w.children.l.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children. .children.w.children.l.mapping.keys.notation.3 +string/which-key.keys.mappings.n.tree.root.children. .children.w.children.l.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children. .children.w.children.l.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children. .children.w.children.l.mapping.keys.internal.3 +string/which-key.keys.mappings.n.tree.root.children. .children.w.children.l.mapping.mode +string/which-key.keys.mappings.n.tree.root.children. .children.w.children.l.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children. .children.w.children.l.mapping.desc +string/which-key.keys.mappings.n.tree.root.children. .children.w.children.l.mapping.id +string/which-key.keys.mappings.n.tree.root.children. .children.w.children.l.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children. .children.w.children.l.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children. .children.w.children.l.mapping.opts.desc +function/0/which-key.keys.mappings.n.tree.root.children. .children.w.children.l.mapping.opts.callback +boolean/which-key.keys.mappings.n.tree.root.children. .children.w.children.l.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children. .children.w.children.l.mapping.cmd +string/which-key.keys.mappings.n.tree.root.children. .children.w.children.l.prefix_i +string/which-key.keys.mappings.n.tree.root.children. .children.w.children.a.prefix_n +string/which-key.keys.mappings.n.tree.root.children. .children.w.children.a.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children. .children.w.children.a.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children. .children.w.children.a.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children. .children.w.children.a.mapping.keys.notation.3 +string/which-key.keys.mappings.n.tree.root.children. .children.w.children.a.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children. .children.w.children.a.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children. .children.w.children.a.mapping.keys.internal.3 +string/which-key.keys.mappings.n.tree.root.children. .children.w.children.a.mapping.mode +string/which-key.keys.mappings.n.tree.root.children. .children.w.children.a.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children. .children.w.children.a.mapping.desc +string/which-key.keys.mappings.n.tree.root.children. .children.w.children.a.mapping.id +string/which-key.keys.mappings.n.tree.root.children. .children.w.children.a.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children. .children.w.children.a.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children. .children.w.children.a.mapping.opts.desc +function/1/which-key.keys.mappings.n.tree.root.children. .children.w.children.a.mapping.opts.callback +boolean/which-key.keys.mappings.n.tree.root.children. .children.w.children.a.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children. .children.w.children.a.mapping.cmd +string/which-key.keys.mappings.n.tree.root.children. .children.w.children.a.prefix_i +string/which-key.keys.mappings.n.tree.root.children. .children.w.children.r.prefix_n +string/which-key.keys.mappings.n.tree.root.children. .children.w.children.r.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children. .children.w.children.r.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children. .children.w.children.r.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children. .children.w.children.r.mapping.keys.notation.3 +string/which-key.keys.mappings.n.tree.root.children. .children.w.children.r.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children. .children.w.children.r.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children. .children.w.children.r.mapping.keys.internal.3 +string/which-key.keys.mappings.n.tree.root.children. .children.w.children.r.mapping.mode +string/which-key.keys.mappings.n.tree.root.children. .children.w.children.r.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children. .children.w.children.r.mapping.desc +string/which-key.keys.mappings.n.tree.root.children. .children.w.children.r.mapping.id +string/which-key.keys.mappings.n.tree.root.children. .children.w.children.r.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children. .children.w.children.r.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children. .children.w.children.r.mapping.opts.desc +function/1/which-key.keys.mappings.n.tree.root.children. .children.w.children.r.mapping.opts.callback +boolean/which-key.keys.mappings.n.tree.root.children. .children.w.children.r.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children. .children.w.children.r.mapping.cmd +string/which-key.keys.mappings.n.tree.root.children. .children.w.children.r.prefix_i +string/which-key.keys.mappings.n.tree.root.children. .children.w.prefix_i +string/which-key.keys.mappings.n.tree.root.children. .children.r.prefix_n +string/which-key.keys.mappings.n.tree.root.children. .children.r.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children. .children.r.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children. .children.r.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children. .children.r.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children. .children.r.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children. .children.r.mapping.prefix +boolean/which-key.keys.mappings.n.tree.root.children. .children.r.mapping.group +string/which-key.keys.mappings.n.tree.root.children. .children.r.children.n.prefix_n +string/which-key.keys.mappings.n.tree.root.children. .children.r.children.n.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children. .children.r.children.n.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children. .children.r.children.n.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children. .children.r.children.n.mapping.keys.notation.3 +string/which-key.keys.mappings.n.tree.root.children. .children.r.children.n.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children. .children.r.children.n.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children. .children.r.children.n.mapping.keys.internal.3 +string/which-key.keys.mappings.n.tree.root.children. .children.r.children.n.mapping.mode +string/which-key.keys.mappings.n.tree.root.children. .children.r.children.n.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children. .children.r.children.n.mapping.desc +string/which-key.keys.mappings.n.tree.root.children. .children.r.children.n.mapping.id +string/which-key.keys.mappings.n.tree.root.children. .children.r.children.n.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children. .children.r.children.n.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children. .children.r.children.n.mapping.opts.desc +function/2/which-key.keys.mappings.n.tree.root.children. .children.r.children.n.mapping.opts.callback +boolean/which-key.keys.mappings.n.tree.root.children. .children.r.children.n.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children. .children.r.children.n.mapping.cmd +string/which-key.keys.mappings.n.tree.root.children. .children.r.children.n.prefix_i +string/which-key.keys.mappings.n.tree.root.children. .children.r.prefix_i +string/which-key.keys.mappings.n.tree.root.children. .prefix_i +string/which-key.keys.mappings.n.tree.root.children.'.prefix_n +string/which-key.keys.mappings.n.tree.root.children.'.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.'.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.'.mapping.keys.internal.1 +boolean/which-key.keys.mappings.n.tree.root.children.'.mapping.group +string/which-key.keys.mappings.n.tree.root.children.'.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.'.mapping.plugin +string/which-key.keys.mappings.n.tree.root.children.'.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.'.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.'.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.'.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.'.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.'.prefix_i +string/which-key.keys.mappings.n.tree.root.children.g.prefix_n +string/which-key.keys.mappings.n.tree.root.children.g.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.g.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.g.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.g.mapping.prefix +boolean/which-key.keys.mappings.n.tree.root.children.g.mapping.group +string/which-key.keys.mappings.n.tree.root.children.g.children.d.prefix_n +string/which-key.keys.mappings.n.tree.root.children.g.children.d.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.g.children.d.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.g.children.d.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.g.children.d.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.g.children.d.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children.g.children.d.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.g.children.d.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.g.children.d.mapping.desc +string/which-key.keys.mappings.n.tree.root.children.g.children.d.mapping.id +string/which-key.keys.mappings.n.tree.root.children.g.children.d.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.g.children.d.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.g.children.d.mapping.opts.desc +function/1/which-key.keys.mappings.n.tree.root.children.g.children.d.mapping.opts.callback +boolean/which-key.keys.mappings.n.tree.root.children.g.children.d.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.g.children.d.mapping.cmd +string/which-key.keys.mappings.n.tree.root.children.g.children.d.prefix_i +string/which-key.keys.mappings.n.tree.root.children.g.children.D.prefix_n +string/which-key.keys.mappings.n.tree.root.children.g.children.D.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.g.children.D.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.g.children.D.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.g.children.D.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.g.children.D.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children.g.children.D.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.g.children.D.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.g.children.D.mapping.desc +string/which-key.keys.mappings.n.tree.root.children.g.children.D.mapping.id +string/which-key.keys.mappings.n.tree.root.children.g.children.D.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.g.children.D.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.g.children.D.mapping.opts.desc +function/1/which-key.keys.mappings.n.tree.root.children.g.children.D.mapping.opts.callback +boolean/which-key.keys.mappings.n.tree.root.children.g.children.D.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.g.children.D.mapping.cmd +string/which-key.keys.mappings.n.tree.root.children.g.children.D.prefix_i +string/which-key.keys.mappings.n.tree.root.children.g.children.x.prefix_n +string/which-key.keys.mappings.n.tree.root.children.g.children.x.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.g.children.x.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.g.children.x.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.g.children.x.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.g.children.x.mapping.keys.internal.2 +boolean/which-key.keys.mappings.n.tree.root.children.g.children.x.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.g.children.x.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.g.children.x.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.g.children.x.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.g.children.x.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.g.children.x.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.g.children.x.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.g.children.x.prefix_i +string/which-key.keys.mappings.n.tree.root.children.g.children.n.prefix_n +string/which-key.keys.mappings.n.tree.root.children.g.children.n.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.g.children.n.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.g.children.n.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.g.children.n.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.g.children.n.mapping.keys.internal.2 +boolean/which-key.keys.mappings.n.tree.root.children.g.children.n.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.g.children.n.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.g.children.n.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.g.children.n.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.g.children.n.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.g.children.n.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.g.children.n.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.g.children.n.prefix_i +string/which-key.keys.mappings.n.tree.root.children.g.children.r.prefix_n +string/which-key.keys.mappings.n.tree.root.children.g.children.r.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.g.children.r.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.g.children.r.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.g.children.r.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.g.children.r.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children.g.children.r.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.g.children.r.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.g.children.r.mapping.desc +string/which-key.keys.mappings.n.tree.root.children.g.children.r.mapping.id +string/which-key.keys.mappings.n.tree.root.children.g.children.r.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.g.children.r.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.g.children.r.mapping.opts.desc +function/2/which-key.keys.mappings.n.tree.root.children.g.children.r.mapping.opts.callback +boolean/which-key.keys.mappings.n.tree.root.children.g.children.r.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.g.children.r.mapping.cmd +string/which-key.keys.mappings.n.tree.root.children.g.children.r.prefix_i +string/which-key.keys.mappings.n.tree.root.children.g.children.i.prefix_n +string/which-key.keys.mappings.n.tree.root.children.g.children.i.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.g.children.i.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.g.children.i.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.g.children.i.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.g.children.i.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children.g.children.i.mapping.id +string/which-key.keys.mappings.n.tree.root.children.g.children.i.mapping.cmd +string/which-key.keys.mappings.n.tree.root.children.g.children.i.mapping.desc +boolean/which-key.keys.mappings.n.tree.root.children.g.children.i.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.g.children.i.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.g.children.i.mapping.label +string/which-key.keys.mappings.n.tree.root.children.g.children.i.mapping.mode +boolean/which-key.keys.mappings.n.tree.root.children.g.children.i.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.g.children.i.mapping.opts.desc +function/1/which-key.keys.mappings.n.tree.root.children.g.children.i.mapping.opts.callback +boolean/which-key.keys.mappings.n.tree.root.children.g.children.i.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.g.children.i.prefix_i +string/which-key.keys.mappings.n.tree.root.children.g.children.v.prefix_n +string/which-key.keys.mappings.n.tree.root.children.g.children.v.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.g.children.v.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.g.children.v.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.g.children.v.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.g.children.v.mapping.keys.internal.2 +boolean/which-key.keys.mappings.n.tree.root.children.g.children.v.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.g.children.v.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.g.children.v.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.g.children.v.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.g.children.v.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.g.children.v.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.g.children.v.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.g.children.v.prefix_i +string/which-key.keys.mappings.n.tree.root.children.g.children.b.prefix_n +string/which-key.keys.mappings.n.tree.root.children.g.children.b.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.g.children.b.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.g.children.b.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.g.children.b.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.g.children.b.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children.g.children.b.mapping.id +string/which-key.keys.mappings.n.tree.root.children.g.children.b.mapping.desc +string/which-key.keys.mappings.n.tree.root.children.g.children.b.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.g.children.b.mapping.cmd +string/which-key.keys.mappings.n.tree.root.children.g.children.b.children.c.prefix_n +string/which-key.keys.mappings.n.tree.root.children.g.children.b.children.c.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.g.children.b.children.c.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.g.children.b.children.c.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.g.children.b.children.c.mapping.keys.notation.3 +string/which-key.keys.mappings.n.tree.root.children.g.children.b.children.c.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.g.children.b.children.c.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children.g.children.b.children.c.mapping.keys.internal.3 +string/which-key.keys.mappings.n.tree.root.children.g.children.b.children.c.mapping.desc +string/which-key.keys.mappings.n.tree.root.children.g.children.b.children.c.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.g.children.b.children.c.mapping.id +string/which-key.keys.mappings.n.tree.root.children.g.children.b.children.c.prefix_i +string/which-key.keys.mappings.n.tree.root.children.g.children.b.prefix_i +string/which-key.keys.mappings.n.tree.root.children.g.children.e.prefix_n +string/which-key.keys.mappings.n.tree.root.children.g.children.e.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.g.children.e.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.g.children.e.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.g.children.e.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.g.children.e.mapping.keys.internal.2 +boolean/which-key.keys.mappings.n.tree.root.children.g.children.e.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.g.children.e.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.g.children.e.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.g.children.e.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.g.children.e.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.g.children.e.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.g.children.e.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.g.children.e.prefix_i +string/which-key.keys.mappings.n.tree.root.children.g.children.f.prefix_n +string/which-key.keys.mappings.n.tree.root.children.g.children.f.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.g.children.f.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.g.children.f.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.g.children.f.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.g.children.f.mapping.keys.internal.2 +boolean/which-key.keys.mappings.n.tree.root.children.g.children.f.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.g.children.f.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.g.children.f.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.g.children.f.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.g.children.f.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.g.children.f.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.g.children.f.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.g.children.f.prefix_i +string/which-key.keys.mappings.n.tree.root.children.g.children.%.prefix_n +string/which-key.keys.mappings.n.tree.root.children.g.children.%.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.g.children.%.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.g.children.%.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.g.children.%.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.g.children.%.mapping.keys.internal.2 +boolean/which-key.keys.mappings.n.tree.root.children.g.children.%.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.g.children.%.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.g.children.%.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.g.children.%.mapping.mode +boolean/which-key.keys.mappings.n.tree.root.children.g.children.%.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.g.children.%.mapping.id +string/which-key.keys.mappings.n.tree.root.children.g.children.%.mapping.label +string/which-key.keys.mappings.n.tree.root.children.g.children.%.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.g.children.%.mapping.cmd +string/which-key.keys.mappings.n.tree.root.children.g.children.%.prefix_i +string/which-key.keys.mappings.n.tree.root.children.g.children.N.prefix_n +string/which-key.keys.mappings.n.tree.root.children.g.children.N.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.g.children.N.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.g.children.N.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.g.children.N.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.g.children.N.mapping.keys.internal.2 +boolean/which-key.keys.mappings.n.tree.root.children.g.children.N.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.g.children.N.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.g.children.N.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.g.children.N.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.g.children.N.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.g.children.N.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.g.children.N.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.g.children.N.prefix_i +string/which-key.keys.mappings.n.tree.root.children.g.children.c.prefix_n +string/which-key.keys.mappings.n.tree.root.children.g.children.c.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.g.children.c.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.g.children.c.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.g.children.c.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.g.children.c.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children.g.children.c.mapping.id +string/which-key.keys.mappings.n.tree.root.children.g.children.c.mapping.desc +string/which-key.keys.mappings.n.tree.root.children.g.children.c.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.g.children.c.mapping.cmd +string/which-key.keys.mappings.n.tree.root.children.g.children.c.children.A.prefix_n +string/which-key.keys.mappings.n.tree.root.children.g.children.c.children.A.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.g.children.c.children.A.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.g.children.c.children.A.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.g.children.c.children.A.mapping.keys.notation.3 +string/which-key.keys.mappings.n.tree.root.children.g.children.c.children.A.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.g.children.c.children.A.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children.g.children.c.children.A.mapping.keys.internal.3 +string/which-key.keys.mappings.n.tree.root.children.g.children.c.children.A.mapping.desc +string/which-key.keys.mappings.n.tree.root.children.g.children.c.children.A.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.g.children.c.children.A.mapping.id +string/which-key.keys.mappings.n.tree.root.children.g.children.c.children.A.prefix_i +string/which-key.keys.mappings.n.tree.root.children.g.children.c.children.O.prefix_n +string/which-key.keys.mappings.n.tree.root.children.g.children.c.children.O.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.g.children.c.children.O.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.g.children.c.children.O.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.g.children.c.children.O.mapping.keys.notation.3 +string/which-key.keys.mappings.n.tree.root.children.g.children.c.children.O.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.g.children.c.children.O.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children.g.children.c.children.O.mapping.keys.internal.3 +string/which-key.keys.mappings.n.tree.root.children.g.children.c.children.O.mapping.desc +string/which-key.keys.mappings.n.tree.root.children.g.children.c.children.O.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.g.children.c.children.O.mapping.id +string/which-key.keys.mappings.n.tree.root.children.g.children.c.children.O.prefix_i +string/which-key.keys.mappings.n.tree.root.children.g.children.c.children.c.prefix_n +string/which-key.keys.mappings.n.tree.root.children.g.children.c.children.c.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.g.children.c.children.c.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.g.children.c.children.c.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.g.children.c.children.c.mapping.keys.notation.3 +string/which-key.keys.mappings.n.tree.root.children.g.children.c.children.c.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.g.children.c.children.c.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children.g.children.c.children.c.mapping.keys.internal.3 +string/which-key.keys.mappings.n.tree.root.children.g.children.c.children.c.mapping.desc +string/which-key.keys.mappings.n.tree.root.children.g.children.c.children.c.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.g.children.c.children.c.mapping.id +string/which-key.keys.mappings.n.tree.root.children.g.children.c.children.c.prefix_i +string/which-key.keys.mappings.n.tree.root.children.g.children.c.children.o.prefix_n +string/which-key.keys.mappings.n.tree.root.children.g.children.c.children.o.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.g.children.c.children.o.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.g.children.c.children.o.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.g.children.c.children.o.mapping.keys.notation.3 +string/which-key.keys.mappings.n.tree.root.children.g.children.c.children.o.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.g.children.c.children.o.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children.g.children.c.children.o.mapping.keys.internal.3 +string/which-key.keys.mappings.n.tree.root.children.g.children.c.children.o.mapping.desc +string/which-key.keys.mappings.n.tree.root.children.g.children.c.children.o.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.g.children.c.children.o.mapping.id +string/which-key.keys.mappings.n.tree.root.children.g.children.c.children.o.prefix_i +string/which-key.keys.mappings.n.tree.root.children.g.children.c.prefix_i +string/which-key.keys.mappings.n.tree.root.children.g.children.g.prefix_n +string/which-key.keys.mappings.n.tree.root.children.g.children.g.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.g.children.g.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.g.children.g.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.g.children.g.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.g.children.g.mapping.keys.internal.2 +boolean/which-key.keys.mappings.n.tree.root.children.g.children.g.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.g.children.g.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.g.children.g.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.g.children.g.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.g.children.g.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.g.children.g.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.g.children.g.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.g.children.g.prefix_i +string/which-key.keys.mappings.n.tree.root.children.g.children.u.prefix_n +string/which-key.keys.mappings.n.tree.root.children.g.children.u.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.g.children.u.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.g.children.u.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.g.children.u.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.g.children.u.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children.g.children.u.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.g.children.u.mapping.name +boolean/which-key.keys.mappings.n.tree.root.children.g.children.u.mapping.preset +boolean/which-key.keys.mappings.n.tree.root.children.g.children.u.mapping.group +string/which-key.keys.mappings.n.tree.root.children.g.children.u.mapping.label +string/which-key.keys.mappings.n.tree.root.children.g.children.u.mapping.prefix +boolean/which-key.keys.mappings.n.tree.root.children.g.children.u.mapping.opts.silent +boolean/which-key.keys.mappings.n.tree.root.children.g.children.u.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.g.children.u.children.a.prefix_n +string/which-key.keys.mappings.n.tree.root.children.g.children.u.children.a.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.g.children.u.children.a.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.g.children.u.children.a.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.g.children.u.children.a.mapping.keys.notation.3 +string/which-key.keys.mappings.n.tree.root.children.g.children.u.children.a.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.g.children.u.children.a.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children.g.children.u.children.a.mapping.keys.internal.3 +string/which-key.keys.mappings.n.tree.root.children.g.children.u.children.a.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.g.children.u.children.a.mapping.name +boolean/which-key.keys.mappings.n.tree.root.children.g.children.u.children.a.mapping.preset +boolean/which-key.keys.mappings.n.tree.root.children.g.children.u.children.a.mapping.group +string/which-key.keys.mappings.n.tree.root.children.g.children.u.children.a.mapping.label +string/which-key.keys.mappings.n.tree.root.children.g.children.u.children.a.mapping.mode +boolean/which-key.keys.mappings.n.tree.root.children.g.children.u.children.a.mapping.opts.silent +boolean/which-key.keys.mappings.n.tree.root.children.g.children.u.children.a.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.g.children.u.children.a.prefix_i +string/which-key.keys.mappings.n.tree.root.children.g.children.u.children.i.prefix_n +string/which-key.keys.mappings.n.tree.root.children.g.children.u.children.i.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.g.children.u.children.i.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.g.children.u.children.i.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.g.children.u.children.i.mapping.keys.notation.3 +string/which-key.keys.mappings.n.tree.root.children.g.children.u.children.i.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.g.children.u.children.i.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children.g.children.u.children.i.mapping.keys.internal.3 +string/which-key.keys.mappings.n.tree.root.children.g.children.u.children.i.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.g.children.u.children.i.mapping.name +boolean/which-key.keys.mappings.n.tree.root.children.g.children.u.children.i.mapping.preset +boolean/which-key.keys.mappings.n.tree.root.children.g.children.u.children.i.mapping.group +string/which-key.keys.mappings.n.tree.root.children.g.children.u.children.i.mapping.label +string/which-key.keys.mappings.n.tree.root.children.g.children.u.children.i.mapping.mode +boolean/which-key.keys.mappings.n.tree.root.children.g.children.u.children.i.mapping.opts.silent +boolean/which-key.keys.mappings.n.tree.root.children.g.children.u.children.i.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.g.children.u.children.i.prefix_i +string/which-key.keys.mappings.n.tree.root.children.g.children.u.prefix_i +string/which-key.keys.mappings.n.tree.root.children.g.children.~.prefix_n +string/which-key.keys.mappings.n.tree.root.children.g.children.~.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.g.children.~.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.g.children.~.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.g.children.~.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.g.children.~.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children.g.children.~.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.g.children.~.mapping.name +boolean/which-key.keys.mappings.n.tree.root.children.g.children.~.mapping.preset +boolean/which-key.keys.mappings.n.tree.root.children.g.children.~.mapping.group +string/which-key.keys.mappings.n.tree.root.children.g.children.~.mapping.label +string/which-key.keys.mappings.n.tree.root.children.g.children.~.mapping.prefix +boolean/which-key.keys.mappings.n.tree.root.children.g.children.~.mapping.opts.silent +boolean/which-key.keys.mappings.n.tree.root.children.g.children.~.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.g.children.~.children.a.prefix_n +string/which-key.keys.mappings.n.tree.root.children.g.children.~.children.a.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.g.children.~.children.a.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.g.children.~.children.a.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.g.children.~.children.a.mapping.keys.notation.3 +string/which-key.keys.mappings.n.tree.root.children.g.children.~.children.a.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.g.children.~.children.a.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children.g.children.~.children.a.mapping.keys.internal.3 +string/which-key.keys.mappings.n.tree.root.children.g.children.~.children.a.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.g.children.~.children.a.mapping.name +boolean/which-key.keys.mappings.n.tree.root.children.g.children.~.children.a.mapping.preset +boolean/which-key.keys.mappings.n.tree.root.children.g.children.~.children.a.mapping.group +string/which-key.keys.mappings.n.tree.root.children.g.children.~.children.a.mapping.label +string/which-key.keys.mappings.n.tree.root.children.g.children.~.children.a.mapping.mode +boolean/which-key.keys.mappings.n.tree.root.children.g.children.~.children.a.mapping.opts.silent +boolean/which-key.keys.mappings.n.tree.root.children.g.children.~.children.a.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.g.children.~.children.a.prefix_i +string/which-key.keys.mappings.n.tree.root.children.g.children.~.children.i.prefix_n +string/which-key.keys.mappings.n.tree.root.children.g.children.~.children.i.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.g.children.~.children.i.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.g.children.~.children.i.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.g.children.~.children.i.mapping.keys.notation.3 +string/which-key.keys.mappings.n.tree.root.children.g.children.~.children.i.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.g.children.~.children.i.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children.g.children.~.children.i.mapping.keys.internal.3 +string/which-key.keys.mappings.n.tree.root.children.g.children.~.children.i.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.g.children.~.children.i.mapping.name +boolean/which-key.keys.mappings.n.tree.root.children.g.children.~.children.i.mapping.preset +boolean/which-key.keys.mappings.n.tree.root.children.g.children.~.children.i.mapping.group +string/which-key.keys.mappings.n.tree.root.children.g.children.~.children.i.mapping.label +string/which-key.keys.mappings.n.tree.root.children.g.children.~.children.i.mapping.mode +boolean/which-key.keys.mappings.n.tree.root.children.g.children.~.children.i.mapping.opts.silent +boolean/which-key.keys.mappings.n.tree.root.children.g.children.~.children.i.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.g.children.~.children.i.prefix_i +string/which-key.keys.mappings.n.tree.root.children.g.children.~.prefix_i +string/which-key.keys.mappings.n.tree.root.children.g.children.'.prefix_n +string/which-key.keys.mappings.n.tree.root.children.g.children.'.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.g.children.'.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.g.children.'.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.g.children.'.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.g.children.'.mapping.keys.internal.2 +boolean/which-key.keys.mappings.n.tree.root.children.g.children.'.mapping.group +string/which-key.keys.mappings.n.tree.root.children.g.children.'.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.g.children.'.mapping.plugin +string/which-key.keys.mappings.n.tree.root.children.g.children.'.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.g.children.'.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.g.children.'.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.g.children.'.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.g.children.'.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.g.children.'.prefix_i +string/which-key.keys.mappings.n.tree.root.children.g.children.`.prefix_n +string/which-key.keys.mappings.n.tree.root.children.g.children.`.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.g.children.`.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.g.children.`.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.g.children.`.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.g.children.`.mapping.keys.internal.2 +boolean/which-key.keys.mappings.n.tree.root.children.g.children.`.mapping.group +string/which-key.keys.mappings.n.tree.root.children.g.children.`.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.g.children.`.mapping.plugin +string/which-key.keys.mappings.n.tree.root.children.g.children.`.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.g.children.`.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.g.children.`.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.g.children.`.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.g.children.`.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.g.children.`.prefix_i +string/which-key.keys.mappings.n.tree.root.children.g.children.U.prefix_n +string/which-key.keys.mappings.n.tree.root.children.g.children.U.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.g.children.U.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.g.children.U.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.g.children.U.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.g.children.U.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children.g.children.U.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.g.children.U.mapping.name +boolean/which-key.keys.mappings.n.tree.root.children.g.children.U.mapping.preset +boolean/which-key.keys.mappings.n.tree.root.children.g.children.U.mapping.group +string/which-key.keys.mappings.n.tree.root.children.g.children.U.mapping.label +string/which-key.keys.mappings.n.tree.root.children.g.children.U.mapping.prefix +boolean/which-key.keys.mappings.n.tree.root.children.g.children.U.mapping.opts.silent +boolean/which-key.keys.mappings.n.tree.root.children.g.children.U.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.g.children.U.children.a.prefix_n +string/which-key.keys.mappings.n.tree.root.children.g.children.U.children.a.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.g.children.U.children.a.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.g.children.U.children.a.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.g.children.U.children.a.mapping.keys.notation.3 +string/which-key.keys.mappings.n.tree.root.children.g.children.U.children.a.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.g.children.U.children.a.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children.g.children.U.children.a.mapping.keys.internal.3 +string/which-key.keys.mappings.n.tree.root.children.g.children.U.children.a.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.g.children.U.children.a.mapping.name +boolean/which-key.keys.mappings.n.tree.root.children.g.children.U.children.a.mapping.preset +boolean/which-key.keys.mappings.n.tree.root.children.g.children.U.children.a.mapping.group +string/which-key.keys.mappings.n.tree.root.children.g.children.U.children.a.mapping.label +string/which-key.keys.mappings.n.tree.root.children.g.children.U.children.a.mapping.mode +boolean/which-key.keys.mappings.n.tree.root.children.g.children.U.children.a.mapping.opts.silent +boolean/which-key.keys.mappings.n.tree.root.children.g.children.U.children.a.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.g.children.U.children.a.prefix_i +string/which-key.keys.mappings.n.tree.root.children.g.children.U.children.i.prefix_n +string/which-key.keys.mappings.n.tree.root.children.g.children.U.children.i.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.g.children.U.children.i.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.g.children.U.children.i.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.g.children.U.children.i.mapping.keys.notation.3 +string/which-key.keys.mappings.n.tree.root.children.g.children.U.children.i.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.g.children.U.children.i.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children.g.children.U.children.i.mapping.keys.internal.3 +string/which-key.keys.mappings.n.tree.root.children.g.children.U.children.i.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.g.children.U.children.i.mapping.name +boolean/which-key.keys.mappings.n.tree.root.children.g.children.U.children.i.mapping.preset +boolean/which-key.keys.mappings.n.tree.root.children.g.children.U.children.i.mapping.group +string/which-key.keys.mappings.n.tree.root.children.g.children.U.children.i.mapping.label +string/which-key.keys.mappings.n.tree.root.children.g.children.U.children.i.mapping.mode +boolean/which-key.keys.mappings.n.tree.root.children.g.children.U.children.i.mapping.opts.silent +boolean/which-key.keys.mappings.n.tree.root.children.g.children.U.children.i.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.g.children.U.children.i.prefix_i +string/which-key.keys.mappings.n.tree.root.children.g.children.U.prefix_i +string/which-key.keys.mappings.n.tree.root.children.g.prefix_i +string/which-key.keys.mappings.n.tree.root.children.M.prefix_n +string/which-key.keys.mappings.n.tree.root.children.M.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.M.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.M.mapping.keys.internal.1 +boolean/which-key.keys.mappings.n.tree.root.children.M.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.M.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.M.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.M.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.M.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.M.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.M.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.M.prefix_i +string/which-key.keys.mappings.n.tree.root.children.v.prefix_n +string/which-key.keys.mappings.n.tree.root.children.v.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.v.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.v.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.v.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.v.mapping.name +boolean/which-key.keys.mappings.n.tree.root.children.v.mapping.preset +boolean/which-key.keys.mappings.n.tree.root.children.v.mapping.group +string/which-key.keys.mappings.n.tree.root.children.v.mapping.label +string/which-key.keys.mappings.n.tree.root.children.v.mapping.prefix +boolean/which-key.keys.mappings.n.tree.root.children.v.mapping.opts.silent +boolean/which-key.keys.mappings.n.tree.root.children.v.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.v.children.a.prefix_n +string/which-key.keys.mappings.n.tree.root.children.v.children.a.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.v.children.a.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.v.children.a.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.v.children.a.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.v.children.a.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children.v.children.a.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.v.children.a.mapping.name +boolean/which-key.keys.mappings.n.tree.root.children.v.children.a.mapping.preset +boolean/which-key.keys.mappings.n.tree.root.children.v.children.a.mapping.group +string/which-key.keys.mappings.n.tree.root.children.v.children.a.mapping.label +string/which-key.keys.mappings.n.tree.root.children.v.children.a.mapping.mode +boolean/which-key.keys.mappings.n.tree.root.children.v.children.a.mapping.opts.silent +boolean/which-key.keys.mappings.n.tree.root.children.v.children.a.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.v.children.a.prefix_i +string/which-key.keys.mappings.n.tree.root.children.v.children.i.prefix_n +string/which-key.keys.mappings.n.tree.root.children.v.children.i.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.v.children.i.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.v.children.i.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.v.children.i.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.v.children.i.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children.v.children.i.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.v.children.i.mapping.name +boolean/which-key.keys.mappings.n.tree.root.children.v.children.i.mapping.preset +boolean/which-key.keys.mappings.n.tree.root.children.v.children.i.mapping.group +string/which-key.keys.mappings.n.tree.root.children.v.children.i.mapping.label +string/which-key.keys.mappings.n.tree.root.children.v.children.i.mapping.mode +boolean/which-key.keys.mappings.n.tree.root.children.v.children.i.mapping.opts.silent +boolean/which-key.keys.mappings.n.tree.root.children.v.children.i.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.v.children.i.prefix_i +string/which-key.keys.mappings.n.tree.root.children.v.prefix_i +string/which-key.keys.mappings.n.tree.root.children.[.prefix_n +string/which-key.keys.mappings.n.tree.root.children.[.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.[.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.[.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.[.mapping.prefix +boolean/which-key.keys.mappings.n.tree.root.children.[.mapping.group +string/which-key.keys.mappings.n.tree.root.children.[.children.d.prefix_n +string/which-key.keys.mappings.n.tree.root.children.[.children.d.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.[.children.d.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.[.children.d.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.[.children.d.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.[.children.d.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children.[.children.d.mapping.prefix +boolean/which-key.keys.mappings.n.tree.root.children.[.children.d.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.[.children.d.mapping.opts.desc +function/1/which-key.keys.mappings.n.tree.root.children.[.children.d.mapping.opts.callback +boolean/which-key.keys.mappings.n.tree.root.children.[.children.d.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.[.children.d.mapping.label +string/which-key.keys.mappings.n.tree.root.children.[.children.d.mapping.id +string/which-key.keys.mappings.n.tree.root.children.[.children.d.mapping.desc +string/which-key.keys.mappings.n.tree.root.children.[.children.d.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.[.children.d.mapping.cmd +string/which-key.keys.mappings.n.tree.root.children.[.children.d.prefix_i +string/which-key.keys.mappings.n.tree.root.children.[.children.s.prefix_n +string/which-key.keys.mappings.n.tree.root.children.[.children.s.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.[.children.s.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.[.children.s.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.[.children.s.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.[.children.s.mapping.keys.internal.2 +boolean/which-key.keys.mappings.n.tree.root.children.[.children.s.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.[.children.s.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.[.children.s.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.[.children.s.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.[.children.s.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.[.children.s.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.[.children.s.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.[.children.s.prefix_i +string/which-key.keys.mappings.n.tree.root.children.[.children.%.prefix_n +string/which-key.keys.mappings.n.tree.root.children.[.children.%.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.[.children.%.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.[.children.%.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.[.children.%.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.[.children.%.mapping.keys.internal.2 +boolean/which-key.keys.mappings.n.tree.root.children.[.children.%.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.[.children.%.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.[.children.%.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.[.children.%.mapping.mode +boolean/which-key.keys.mappings.n.tree.root.children.[.children.%.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.[.children.%.mapping.id +string/which-key.keys.mappings.n.tree.root.children.[.children.%.mapping.label +string/which-key.keys.mappings.n.tree.root.children.[.children.%.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.[.children.%.mapping.cmd +string/which-key.keys.mappings.n.tree.root.children.[.children.%.prefix_i +string/which-key.keys.mappings.n.tree.root.children.[.children.<.prefix_n +string/which-key.keys.mappings.n.tree.root.children.[.children.<.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.[.children.<.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.[.children.<.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.[.children.<.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.[.children.<.mapping.keys.internal.2 +boolean/which-key.keys.mappings.n.tree.root.children.[.children.<.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.[.children.<.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.[.children.<.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.[.children.<.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.[.children.<.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.[.children.<.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.[.children.<.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.[.children.<.prefix_i +string/which-key.keys.mappings.n.tree.root.children.[.children.M.prefix_n +string/which-key.keys.mappings.n.tree.root.children.[.children.M.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.[.children.M.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.[.children.M.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.[.children.M.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.[.children.M.mapping.keys.internal.2 +boolean/which-key.keys.mappings.n.tree.root.children.[.children.M.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.[.children.M.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.[.children.M.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.[.children.M.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.[.children.M.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.[.children.M.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.[.children.M.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.[.children.M.prefix_i +string/which-key.keys.mappings.n.tree.root.children.[.children.{.prefix_n +string/which-key.keys.mappings.n.tree.root.children.[.children.{.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.[.children.{.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.[.children.{.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.[.children.{.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.[.children.{.mapping.keys.internal.2 +boolean/which-key.keys.mappings.n.tree.root.children.[.children.{.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.[.children.{.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.[.children.{.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.[.children.{.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.[.children.{.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.[.children.{.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.[.children.{.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.[.children.{.prefix_i +string/which-key.keys.mappings.n.tree.root.children.[.children.m.prefix_n +string/which-key.keys.mappings.n.tree.root.children.[.children.m.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.[.children.m.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.[.children.m.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.[.children.m.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.[.children.m.mapping.keys.internal.2 +boolean/which-key.keys.mappings.n.tree.root.children.[.children.m.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.[.children.m.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.[.children.m.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.[.children.m.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.[.children.m.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.[.children.m.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.[.children.m.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.[.children.m.prefix_i +string/which-key.keys.mappings.n.tree.root.children.[.children.(.prefix_n +string/which-key.keys.mappings.n.tree.root.children.[.children.(.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.[.children.(.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.[.children.(.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.[.children.(.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.[.children.(.mapping.keys.internal.2 +boolean/which-key.keys.mappings.n.tree.root.children.[.children.(.mapping.preset +string/which-key.keys.mappings.n.tree.root.children.[.children.(.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.[.children.(.mapping.label +boolean/which-key.keys.mappings.n.tree.root.children.[.children.(.mapping.opts.silent +string/which-key.keys.mappings.n.tree.root.children.[.children.(.mapping.opts.desc +boolean/which-key.keys.mappings.n.tree.root.children.[.children.(.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.[.children.(.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.[.children.(.prefix_i +string/which-key.keys.mappings.n.tree.root.children.[.prefix_i +string/which-key.keys.mappings.n.tree.root.children.y.prefix_n +string/which-key.keys.mappings.n.tree.root.children.y.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.y.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.y.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.y.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.y.mapping.name +boolean/which-key.keys.mappings.n.tree.root.children.y.mapping.preset +boolean/which-key.keys.mappings.n.tree.root.children.y.mapping.group +string/which-key.keys.mappings.n.tree.root.children.y.mapping.label +string/which-key.keys.mappings.n.tree.root.children.y.mapping.prefix +boolean/which-key.keys.mappings.n.tree.root.children.y.mapping.opts.silent +boolean/which-key.keys.mappings.n.tree.root.children.y.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.y.children.a.prefix_n +string/which-key.keys.mappings.n.tree.root.children.y.children.a.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.y.children.a.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.y.children.a.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.y.children.a.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.y.children.a.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children.y.children.a.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.y.children.a.mapping.name +boolean/which-key.keys.mappings.n.tree.root.children.y.children.a.mapping.preset +boolean/which-key.keys.mappings.n.tree.root.children.y.children.a.mapping.group +string/which-key.keys.mappings.n.tree.root.children.y.children.a.mapping.label +string/which-key.keys.mappings.n.tree.root.children.y.children.a.mapping.mode +boolean/which-key.keys.mappings.n.tree.root.children.y.children.a.mapping.opts.silent +boolean/which-key.keys.mappings.n.tree.root.children.y.children.a.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.y.children.a.prefix_i +string/which-key.keys.mappings.n.tree.root.children.y.children.i.prefix_n +string/which-key.keys.mappings.n.tree.root.children.y.children.i.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.y.children.i.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.y.children.i.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.y.children.i.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.y.children.i.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children.y.children.i.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.y.children.i.mapping.name +boolean/which-key.keys.mappings.n.tree.root.children.y.children.i.mapping.preset +boolean/which-key.keys.mappings.n.tree.root.children.y.children.i.mapping.group +string/which-key.keys.mappings.n.tree.root.children.y.children.i.mapping.label +string/which-key.keys.mappings.n.tree.root.children.y.children.i.mapping.mode +boolean/which-key.keys.mappings.n.tree.root.children.y.children.i.mapping.opts.silent +boolean/which-key.keys.mappings.n.tree.root.children.y.children.i.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.y.children.i.prefix_i +string/which-key.keys.mappings.n.tree.root.children.y.prefix_i +string/which-key.keys.mappings.n.tree.root.children.c.prefix_n +string/which-key.keys.mappings.n.tree.root.children.c.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.c.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.c.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.c.mapping.mode +string/which-key.keys.mappings.n.tree.root.children.c.mapping.name +boolean/which-key.keys.mappings.n.tree.root.children.c.mapping.preset +boolean/which-key.keys.mappings.n.tree.root.children.c.mapping.group +string/which-key.keys.mappings.n.tree.root.children.c.mapping.label +string/which-key.keys.mappings.n.tree.root.children.c.mapping.prefix +boolean/which-key.keys.mappings.n.tree.root.children.c.mapping.opts.silent +boolean/which-key.keys.mappings.n.tree.root.children.c.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.c.children.a.prefix_n +string/which-key.keys.mappings.n.tree.root.children.c.children.a.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.c.children.a.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.c.children.a.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.c.children.a.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.c.children.a.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children.c.children.a.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.c.children.a.mapping.name +boolean/which-key.keys.mappings.n.tree.root.children.c.children.a.mapping.preset +boolean/which-key.keys.mappings.n.tree.root.children.c.children.a.mapping.group +string/which-key.keys.mappings.n.tree.root.children.c.children.a.mapping.label +string/which-key.keys.mappings.n.tree.root.children.c.children.a.mapping.mode +boolean/which-key.keys.mappings.n.tree.root.children.c.children.a.mapping.opts.silent +boolean/which-key.keys.mappings.n.tree.root.children.c.children.a.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.c.children.a.prefix_i +string/which-key.keys.mappings.n.tree.root.children.c.children.i.prefix_n +string/which-key.keys.mappings.n.tree.root.children.c.children.i.mapping.keys.keys +string/which-key.keys.mappings.n.tree.root.children.c.children.i.mapping.keys.notation.1 +string/which-key.keys.mappings.n.tree.root.children.c.children.i.mapping.keys.notation.2 +string/which-key.keys.mappings.n.tree.root.children.c.children.i.mapping.keys.internal.1 +string/which-key.keys.mappings.n.tree.root.children.c.children.i.mapping.keys.internal.2 +string/which-key.keys.mappings.n.tree.root.children.c.children.i.mapping.prefix +string/which-key.keys.mappings.n.tree.root.children.c.children.i.mapping.name +boolean/which-key.keys.mappings.n.tree.root.children.c.children.i.mapping.preset +boolean/which-key.keys.mappings.n.tree.root.children.c.children.i.mapping.group +string/which-key.keys.mappings.n.tree.root.children.c.children.i.mapping.label +string/which-key.keys.mappings.n.tree.root.children.c.children.i.mapping.mode +boolean/which-key.keys.mappings.n.tree.root.children.c.children.i.mapping.opts.silent +boolean/which-key.keys.mappings.n.tree.root.children.c.children.i.mapping.opts.noremap +string/which-key.keys.mappings.n.tree.root.children.c.children.i.prefix_i +string/which-key.keys.mappings.n.tree.root.children.c.prefix_i +string/which-key.keys.mappings.n.tree.root.prefix_i +string/which-key.keys.mappings.n.mode +string/which-key.keys.mappings.n36.tree.root.prefix_n +string/which-key.keys.mappings.n36.tree.root.mapping.keys.keys +string/which-key.keys.mappings.n36.tree.root.mapping.prefix +boolean/which-key.keys.mappings.n36.tree.root.mapping.group +string/which-key.keys.mappings.n36.tree.root.prefix_i +string/which-key.keys.mappings.n36.mode +number/which-key.keys.mappings.n36.buf +string/which-key.keys.mappings.i.tree.root.prefix_n +string/which-key.keys.mappings.i.tree.root.mapping.keys.keys +string/which-key.keys.mappings.i.tree.root.mapping.prefix +boolean/which-key.keys.mappings.i.tree.root.mapping.group +string/which-key.keys.mappings.i.tree.root.children.^M.prefix_n +string/which-key.keys.mappings.i.tree.root.children.^M.mapping.keys.keys +string/which-key.keys.mappings.i.tree.root.children.^M.mapping.keys.notation.1 +string/which-key.keys.mappings.i.tree.root.children.^M.mapping.keys.internal.1 +string/which-key.keys.mappings.i.tree.root.children.^M.mapping.id +string/which-key.keys.mappings.i.tree.root.children.^M.mapping.desc +string/which-key.keys.mappings.i.tree.root.children.^M.mapping.prefix +string/which-key.keys.mappings.i.tree.root.children.^M.mapping.cmd +string/which-key.keys.mappings.i.tree.root.children.^M.prefix_i +string/which-key.keys.mappings.i.tree.root.children.^W.prefix_n +string/which-key.keys.mappings.i.tree.root.children.^W.mapping.keys.keys +string/which-key.keys.mappings.i.tree.root.children.^W.mapping.keys.notation.1 +string/which-key.keys.mappings.i.tree.root.children.^W.mapping.keys.internal.1 +string/which-key.keys.mappings.i.tree.root.children.^W.mapping.id +string/which-key.keys.mappings.i.tree.root.children.^W.mapping.desc +string/which-key.keys.mappings.i.tree.root.children.^W.mapping.prefix +string/which-key.keys.mappings.i.tree.root.children.^W.mapping.cmd +string/which-key.keys.mappings.i.tree.root.children.^W.prefix_i +string/which-key.keys.mappings.i.tree.root.children.<80>^D .prefix_n +string/which-key.keys.mappings.i.tree.root.children.<80>^D .mapping.keys.keys +string/which-key.keys.mappings.i.tree.root.children.<80>^D .mapping.keys.notation.1 +string/which-key.keys.mappings.i.tree.root.children.<80>^D .mapping.keys.internal.1 +string/which-key.keys.mappings.i.tree.root.children.<80>^D .mapping.desc +string/which-key.keys.mappings.i.tree.root.children.<80>^D .mapping.prefix +string/which-key.keys.mappings.i.tree.root.children.<80>^D .mapping.id +string/which-key.keys.mappings.i.tree.root.children.<80>^D .prefix_i +string/which-key.keys.mappings.i.tree.root.children.<80>kB.prefix_n +string/which-key.keys.mappings.i.tree.root.children.<80>kB.mapping.keys.keys +string/which-key.keys.mappings.i.tree.root.children.<80>kB.mapping.keys.notation.1 +string/which-key.keys.mappings.i.tree.root.children.<80>kB.mapping.keys.internal.1 +string/which-key.keys.mappings.i.tree.root.children.<80>kB.mapping.desc +string/which-key.keys.mappings.i.tree.root.children.<80>kB.mapping.prefix +string/which-key.keys.mappings.i.tree.root.children.<80>kB.mapping.id +string/which-key.keys.mappings.i.tree.root.children.<80>kB.prefix_i +string/which-key.keys.mappings.i.tree.root.children.^N.prefix_n +string/which-key.keys.mappings.i.tree.root.children.^N.mapping.keys.keys +string/which-key.keys.mappings.i.tree.root.children.^N.mapping.keys.notation.1 +string/which-key.keys.mappings.i.tree.root.children.^N.mapping.keys.internal.1 +string/which-key.keys.mappings.i.tree.root.children.^N.mapping.desc +string/which-key.keys.mappings.i.tree.root.children.^N.mapping.prefix +string/which-key.keys.mappings.i.tree.root.children.^N.mapping.id +string/which-key.keys.mappings.i.tree.root.children.^N.prefix_i +string/which-key.keys.mappings.i.tree.root.children.^P.prefix_n +string/which-key.keys.mappings.i.tree.root.children.^P.mapping.keys.keys +string/which-key.keys.mappings.i.tree.root.children.^P.mapping.keys.notation.1 +string/which-key.keys.mappings.i.tree.root.children.^P.mapping.keys.internal.1 +string/which-key.keys.mappings.i.tree.root.children.^P.mapping.desc +string/which-key.keys.mappings.i.tree.root.children.^P.mapping.prefix +string/which-key.keys.mappings.i.tree.root.children.^P.mapping.id +string/which-key.keys.mappings.i.tree.root.children.^P.prefix_i +string/which-key.keys.mappings.i.tree.root.children.^U.prefix_n +string/which-key.keys.mappings.i.tree.root.children.^U.mapping.keys.keys +string/which-key.keys.mappings.i.tree.root.children.^U.mapping.keys.notation.1 +string/which-key.keys.mappings.i.tree.root.children.^U.mapping.keys.internal.1 +string/which-key.keys.mappings.i.tree.root.children.^U.mapping.id +string/which-key.keys.mappings.i.tree.root.children.^U.mapping.desc +string/which-key.keys.mappings.i.tree.root.children.^U.mapping.prefix +string/which-key.keys.mappings.i.tree.root.children.^U.mapping.cmd +string/which-key.keys.mappings.i.tree.root.children.^U.prefix_i +string/which-key.keys.mappings.i.tree.root.children.^I.prefix_n +string/which-key.keys.mappings.i.tree.root.children.^I.mapping.keys.keys +string/which-key.keys.mappings.i.tree.root.children.^I.mapping.keys.notation.1 +string/which-key.keys.mappings.i.tree.root.children.^I.mapping.keys.internal.1 +string/which-key.keys.mappings.i.tree.root.children.^I.mapping.desc +string/which-key.keys.mappings.i.tree.root.children.^I.mapping.prefix +string/which-key.keys.mappings.i.tree.root.children.^I.mapping.id +string/which-key.keys.mappings.i.tree.root.children.^I.prefix_i +string/which-key.keys.mappings.i.tree.root.children.^R.prefix_n +string/which-key.keys.mappings.i.tree.root.children.^R.mapping.keys.keys +string/which-key.keys.mappings.i.tree.root.children.^R.mapping.keys.notation.1 +string/which-key.keys.mappings.i.tree.root.children.^R.mapping.keys.internal.1 +boolean/which-key.keys.mappings.i.tree.root.children.^R.mapping.group +string/which-key.keys.mappings.i.tree.root.children.^R.mapping.prefix +string/which-key.keys.mappings.i.tree.root.children.^R.mapping.plugin +string/which-key.keys.mappings.i.tree.root.children.^R.mapping.label +boolean/which-key.keys.mappings.i.tree.root.children.^R.mapping.opts.silent +string/which-key.keys.mappings.i.tree.root.children.^R.mapping.opts.desc +boolean/which-key.keys.mappings.i.tree.root.children.^R.mapping.opts.noremap +string/which-key.keys.mappings.i.tree.root.children.^R.mapping.mode +string/which-key.keys.mappings.i.tree.root.children.^R.prefix_i +string/which-key.keys.mappings.i.tree.root.children.^E.prefix_n +string/which-key.keys.mappings.i.tree.root.children.^E.mapping.keys.keys +string/which-key.keys.mappings.i.tree.root.children.^E.mapping.keys.notation.1 +string/which-key.keys.mappings.i.tree.root.children.^E.mapping.keys.internal.1 +string/which-key.keys.mappings.i.tree.root.children.^E.mapping.desc +string/which-key.keys.mappings.i.tree.root.children.^E.mapping.prefix +string/which-key.keys.mappings.i.tree.root.children.^E.mapping.id +string/which-key.keys.mappings.i.tree.root.children.^E.prefix_i +string/which-key.keys.mappings.i.tree.root.prefix_i +string/which-key.keys.mappings.i.mode +string/which-key.keys.mappings.n66.tree.root.prefix_n +string/which-key.keys.mappings.n66.tree.root.mapping.keys.keys +string/which-key.keys.mappings.n66.tree.root.mapping.prefix +boolean/which-key.keys.mappings.n66.tree.root.mapping.group +string/which-key.keys.mappings.n66.tree.root.prefix_i +string/which-key.keys.mappings.n66.mode +number/which-key.keys.mappings.n66.buf +string/which-key.keys.mappings.n65.tree.root.prefix_n +string/which-key.keys.mappings.n65.tree.root.mapping.keys.keys +string/which-key.keys.mappings.n65.tree.root.mapping.prefix +boolean/which-key.keys.mappings.n65.tree.root.mapping.group +string/which-key.keys.mappings.n65.tree.root.prefix_i +string/which-key.keys.mappings.n65.mode +number/which-key.keys.mappings.n65.buf +string/which-key.keys.mappings.n61.tree.root.prefix_n +string/which-key.keys.mappings.n61.tree.root.mapping.keys.keys +string/which-key.keys.mappings.n61.tree.root.mapping.prefix +boolean/which-key.keys.mappings.n61.tree.root.mapping.group +string/which-key.keys.mappings.n61.tree.root.prefix_i +string/which-key.keys.mappings.n61.mode +number/which-key.keys.mappings.n61.buf +string/which-key.keys.mappings.n56.tree.root.prefix_n +string/which-key.keys.mappings.n56.tree.root.mapping.keys.keys +string/which-key.keys.mappings.n56.tree.root.mapping.prefix +boolean/which-key.keys.mappings.n56.tree.root.mapping.group +string/which-key.keys.mappings.n56.tree.root.prefix_i +string/which-key.keys.mappings.n56.mode +number/which-key.keys.mappings.n56.buf +string/which-key.keys.mappings.n49.tree.root.prefix_n +string/which-key.keys.mappings.n49.tree.root.mapping.keys.keys +string/which-key.keys.mappings.n49.tree.root.mapping.prefix +boolean/which-key.keys.mappings.n49.tree.root.mapping.group +string/which-key.keys.mappings.n49.tree.root.prefix_i +string/which-key.keys.mappings.n49.mode +number/which-key.keys.mappings.n49.buf +string/which-key.keys.mappings.n51.tree.root.prefix_n +string/which-key.keys.mappings.n51.tree.root.mapping.keys.keys +string/which-key.keys.mappings.n51.tree.root.mapping.prefix +boolean/which-key.keys.mappings.n51.tree.root.mapping.group +string/which-key.keys.mappings.n51.tree.root.prefix_i +string/which-key.keys.mappings.n51.mode +number/which-key.keys.mappings.n51.buf +string/which-key.keys.mappings.n44.tree.root.prefix_n +string/which-key.keys.mappings.n44.tree.root.mapping.keys.keys +string/which-key.keys.mappings.n44.tree.root.mapping.prefix +boolean/which-key.keys.mappings.n44.tree.root.mapping.group +string/which-key.keys.mappings.n44.tree.root.prefix_i +string/which-key.keys.mappings.n44.mode +number/which-key.keys.mappings.n44.buf +string/which-key.keys.mappings.n45.tree.root.prefix_n +string/which-key.keys.mappings.n45.tree.root.mapping.keys.keys +string/which-key.keys.mappings.n45.tree.root.mapping.prefix +boolean/which-key.keys.mappings.n45.tree.root.mapping.group +string/which-key.keys.mappings.n45.tree.root.prefix_i +string/which-key.keys.mappings.n45.mode +number/which-key.keys.mappings.n45.buf +string/which-key.keys.mappings.n58.tree.root.prefix_n +string/which-key.keys.mappings.n58.tree.root.mapping.keys.keys +string/which-key.keys.mappings.n58.tree.root.mapping.prefix +boolean/which-key.keys.mappings.n58.tree.root.mapping.group +string/which-key.keys.mappings.n58.tree.root.prefix_i +string/which-key.keys.mappings.n58.mode +number/which-key.keys.mappings.n58.buf +string/which-key.keys.mappings.n57.tree.root.prefix_n +string/which-key.keys.mappings.n57.tree.root.mapping.keys.keys +string/which-key.keys.mappings.n57.tree.root.mapping.prefix +boolean/which-key.keys.mappings.n57.tree.root.mapping.group +string/which-key.keys.mappings.n57.tree.root.prefix_i +string/which-key.keys.mappings.n57.mode +number/which-key.keys.mappings.n57.buf +string/which-key.keys.mappings.n55.tree.root.prefix_n +string/which-key.keys.mappings.n55.tree.root.mapping.keys.keys +string/which-key.keys.mappings.n55.tree.root.mapping.prefix +boolean/which-key.keys.mappings.n55.tree.root.mapping.group +string/which-key.keys.mappings.n55.tree.root.prefix_i +string/which-key.keys.mappings.n55.mode +number/which-key.keys.mappings.n55.buf +string/which-key.keys.mappings.n53.tree.root.prefix_n +string/which-key.keys.mappings.n53.tree.root.mapping.keys.keys +string/which-key.keys.mappings.n53.tree.root.mapping.prefix +boolean/which-key.keys.mappings.n53.tree.root.mapping.group +string/which-key.keys.mappings.n53.tree.root.prefix_i +string/which-key.keys.mappings.n53.mode +number/which-key.keys.mappings.n53.buf +string/which-key.keys.mappings.o22.tree.root.prefix_n +string/which-key.keys.mappings.o22.tree.root.mapping.keys.keys +string/which-key.keys.mappings.o22.tree.root.mapping.prefix +boolean/which-key.keys.mappings.o22.tree.root.mapping.group +string/which-key.keys.mappings.o22.tree.root.prefix_i +string/which-key.keys.mappings.o22.mode +number/which-key.keys.mappings.o22.buf +string/which-key.keys.mappings.n52.tree.root.prefix_n +string/which-key.keys.mappings.n52.tree.root.mapping.keys.keys +string/which-key.keys.mappings.n52.tree.root.mapping.prefix +boolean/which-key.keys.mappings.n52.tree.root.mapping.group +string/which-key.keys.mappings.n52.tree.root.prefix_i +string/which-key.keys.mappings.n52.mode +number/which-key.keys.mappings.n52.buf +string/which-key.keys.mappings.n43.tree.root.prefix_n +string/which-key.keys.mappings.n43.tree.root.mapping.keys.keys +string/which-key.keys.mappings.n43.tree.root.mapping.prefix +boolean/which-key.keys.mappings.n43.tree.root.mapping.group +string/which-key.keys.mappings.n43.tree.root.prefix_i +string/which-key.keys.mappings.n43.mode +number/which-key.keys.mappings.n43.buf +string/which-key.keys.mappings.n29.tree.root.prefix_n +string/which-key.keys.mappings.n29.tree.root.mapping.keys.keys +string/which-key.keys.mappings.n29.tree.root.mapping.prefix +boolean/which-key.keys.mappings.n29.tree.root.mapping.group +string/which-key.keys.mappings.n29.tree.root.prefix_i +string/which-key.keys.mappings.n29.mode +number/which-key.keys.mappings.n29.buf +string/which-key.keys.mappings.n34.tree.root.prefix_n +string/which-key.keys.mappings.n34.tree.root.mapping.keys.keys +string/which-key.keys.mappings.n34.tree.root.mapping.prefix +boolean/which-key.keys.mappings.n34.tree.root.mapping.group +string/which-key.keys.mappings.n34.tree.root.prefix_i +string/which-key.keys.mappings.n34.mode +number/which-key.keys.mappings.n34.buf +string/which-key.keys.mappings.n12.tree.root.prefix_n +string/which-key.keys.mappings.n12.tree.root.mapping.keys.keys +string/which-key.keys.mappings.n12.tree.root.mapping.prefix +boolean/which-key.keys.mappings.n12.tree.root.mapping.group +string/which-key.keys.mappings.n12.tree.root.prefix_i +string/which-key.keys.mappings.n12.mode +number/which-key.keys.mappings.n12.buf +string/which-key.keys.mappings.n32.tree.root.prefix_n +string/which-key.keys.mappings.n32.tree.root.mapping.keys.keys +string/which-key.keys.mappings.n32.tree.root.mapping.prefix +boolean/which-key.keys.mappings.n32.tree.root.mapping.group +string/which-key.keys.mappings.n32.tree.root.prefix_i +string/which-key.keys.mappings.n32.mode +number/which-key.keys.mappings.n32.buf +string/which-key.keys.mappings.n48.tree.root.prefix_n +string/which-key.keys.mappings.n48.tree.root.mapping.keys.keys +string/which-key.keys.mappings.n48.tree.root.mapping.prefix +boolean/which-key.keys.mappings.n48.tree.root.mapping.group +string/which-key.keys.mappings.n48.tree.root.prefix_i +string/which-key.keys.mappings.n48.mode +number/which-key.keys.mappings.n48.buf +function/0/which-key.keys.setup +function/4/which-key.keys.add_hooks +boolean/which-key.keys.operators.d +boolean/which-key.keys.operators.gc +boolean/which-key.keys.operators.! +boolean/which-key.keys.operators.v +boolean/which-key.keys.operators.gu +boolean/which-key.keys.operators.c +boolean/which-key.keys.operators.gU +boolean/which-key.keys.operators.g~ +boolean/which-key.keys.operators. +boolean/which-key.keys.operators.> +boolean/which-key.keys.operators.y +boolean/which-key.keys.operators.zf +boolean/which-key.keys.blacklist.i.k +boolean/which-key.keys.blacklist.i.j +boolean/which-key.keys.blacklist.v.k +boolean/which-key.keys.blacklist.v.j +function/1/which-key.keys.update +function/2/which-key.keys.update_keymaps +function/0/which-key.keys.dump +function/0/which-key.keys.check_health +boolean/which-key.keys.nowait.g` +boolean/which-key.keys.nowait.' +boolean/which-key.keys.nowait." +boolean/which-key.keys.nowait.g' +boolean/which-key.keys.nowait. +boolean/which-key.keys.nowait.` +function/2/which-key.keys.get_tree +function/1/which-key.keys.get_operator +function/3/which-key.keys.get_mappings +function/1/Comment.ft.calculate +function/2/Comment.ft.get +function/2/Comment.ft.contains +function/2/Comment.ft.set +boolean/nvim-tree.diagnostics.show_on_open_dirs +boolean/nvim-tree.diagnostics.show_on_dirs +function/1/nvim-tree.diagnostics.setup +number/nvim-tree.diagnostics.debounce_delay +function/0/nvim-tree.diagnostics.clear +boolean/nvim-tree.diagnostics.enable +number/nvim-tree.diagnostics.severity.max +number/nvim-tree.diagnostics.severity.min +function/0/nvim-tree.diagnostics.update +function/1/Comment.config.get +string/Comment.config.config.extra.below +string/Comment.config.config.extra.eol +string/Comment.config.config.extra.above +boolean/Comment.config.config.sticky +boolean/Comment.config.config.padding +string/Comment.config.config.toggler.line +string/Comment.config.config.toggler.block +boolean/Comment.config.config.mappings.basic +boolean/Comment.config.config.mappings.extra +string/Comment.config.config.opleader.line +string/Comment.config.config.opleader.block +function/2/Comment.config.set +function/1/Comment.setup +function/5/nvim-autopairs.completion.handlers.lisp +function/5/nvim-autopairs.completion.handlers.* +function/0/nvim-autopairs.conds.none +function/0/nvim-autopairs.conds.is_bracket_line +function/1/nvim-autopairs.conds.invert +function/2/nvim-autopairs.conds.before_regex +function/1/nvim-autopairs.conds.before_text +function/2/nvim-autopairs.conds.after_regex +function/1/nvim-autopairs.conds.not_before_text +function/0/nvim-autopairs.conds.not_inside_quote +function/0/nvim-autopairs.conds.is_bracket_line_move +function/1/nvim-autopairs.conds.not_after_text_check +function/1/nvim-autopairs.conds.after_text_check +function/2/nvim-autopairs.conds.not_before_regex_check +function/2/nvim-autopairs.conds.not_before_char +function/0/nvim-autopairs.conds.is_bracket_in_quote +function/2/nvim-autopairs.conds.after_regex_check +function/2/nvim-autopairs.conds.not_before_regex +function/0/nvim-autopairs.conds.is_inside_quote +function/1/nvim-autopairs.conds.after_text +function/1/nvim-autopairs.conds.not_after_text +function/2/nvim-autopairs.conds.not_after_regex_check +function/0/nvim-autopairs.conds.is_end_line +function/0/nvim-autopairs.conds.done +function/0/nvim-autopairs.conds.move_right +function/2/nvim-autopairs.conds.before_regex_check +function/1/nvim-autopairs.conds.not_filetypes +function/0/nvim-autopairs.conds.not_add_quote_inside_quote +function/2/nvim-autopairs.conds.not_after_regex +function/1/nvim-autopairs.conds.before_text_check +function/1/nvim-autopairs.conds.not_before_text_check +function/2/nvim-autopairs.rule.can_move +function/2/nvim-autopairs.rule.get_end_pair +function/2/nvim-autopairs.rule.get_end_pair_length +function/2/nvim-autopairs.rule.with_cr +function/2/nvim-autopairs.rule.can_pair +function/2/nvim-autopairs.rule.get_map_cr +function/1/nvim-autopairs.rule.use_multibyte +function/2/nvim-autopairs.rule.only_cr +function/2/nvim-autopairs.rule.use_key +function/2/nvim-autopairs.rule.replace_map_cr +function/3/nvim-autopairs.rule.replace_endpair +function/2/nvim-autopairs.rule.set_end_pair_length +function/2/nvim-autopairs.rule.with_del +function/2/nvim-autopairs.rule.end_wise +function/2/nvim-autopairs.rule.can_cr +function/2/nvim-autopairs.rule.with_move +function/3/nvim-autopairs.rule.with_pair +function/2/nvim-autopairs.rule.can_del +function/3/nvim-autopairs.rule.use_regex +function/2/nvim-autopairs.rule.use_undo +function/0/nvim-autopairs.rule.new +function/0/math.sqrt +function/0/math.log10 +function/0/math.exp +function/0/math.sin +function/0/math.cos +function/0/math.tan +function/0/math.asin +function/0/math.acos +function/0/math.atan +function/0/math.sinh +function/0/math.cosh +function/0/math.tanh +function/0/math.frexp +function/0/math.modf +function/0/math.log +function/1/math.deg +function/1/math.rad +function/0/math.atan2 +function/0/math.pow +function/0/math.fmod +function/0/math.ldexp +function/0/math.min +function/0/math.max +number/math.pi +number/math.huge +function/0/math.random +function/0/math.randomseed +function/0/math.abs +function/0/math.floor +function/0/math.ceil +function/1/nvim-tree.actions.node.file-popup.setup +string/nvim-tree.actions.node.file-popup.open_win_config.relative +string/nvim-tree.actions.node.file-popup.open_win_config.style +number/nvim-tree.actions.node.file-popup.open_win_config.row +string/nvim-tree.actions.node.file-popup.open_win_config.border +number/nvim-tree.actions.node.file-popup.open_win_config.col +function/1/nvim-tree.actions.node.file-popup.toggle_file_info +function/0/nvim-tree.actions.node.file-popup.close_popup +function/1/vscode.setup +function/1/vscode.change_style +string/jit.arch +number/jit.version_num +string/jit.os +function/0/jit.flush +function/0/jit.on +function/0/jit.off +function/0/jit.security +function/0/jit.status +string/jit.version +function/0/jit.attach +function/2/cmp.entry.execute +function/2/cmp.entry.convert_range_encoding +function/1/cmp.entry.get_overwrite +function/1/cmp.entry.get_commit_characters +function/1/cmp.entry.get_documentation +function/1/cmp.entry.get_insert_text +function/1/cmp.entry.get_word +function/2/cmp.entry.resolve +function/1/cmp.entry.is_deprecated +function/3/cmp.entry.get_view +function/1/cmp.entry.get_filter_text +function/1/cmp.entry.get_kind +function/1/cmp.entry.get_offset +function/1/cmp.entry.get_completion_item +function/3/cmp.entry.match +function/2/cmp.entry.get_vim_item +function/3/cmp.entry.fill_defaults +function/4/cmp.entry.new +function/1/cmp.entry.get_replace_range +function/1/cmp.entry.get_insert_range +function/0/table.clear +function/2/table.foreachi +function/2/table.foreach +function/1/table.getn +function/0/table.maxn +function/0/table.insert +function/2/table.remove +function/5/table.move +function/0/table.concat +function/0/table.sort +function/0/table.new +function/1/nvim-tree.events.on_tree_close +function/1/nvim-tree.events.on_tree_resize +function/2/nvim-tree.events.subscribe +function/0/nvim-tree.events._dispatch_ready +function/0/nvim-tree.events._dispatch_on_tree_open +function/2/nvim-tree.events._dispatch_node_renamed +function/1/nvim-tree.events._dispatch_file_removed +function/1/nvim-tree.events._dispatch_file_created +function/1/nvim-tree.events._dispatch_folder_created +function/2/nvim-tree.events._dispatch_will_rename_node +function/1/nvim-tree.events._dispatch_folder_removed +function/0/nvim-tree.events._dispatch_on_tree_close +function/1/nvim-tree.events._dispatch_on_tree_resize +function/1/nvim-tree.events._dispatch_tree_attached_post +function/1/nvim-tree.events.on_nvim_tree_ready +function/1/nvim-tree.events.on_node_renamed +function/1/nvim-tree.events.on_file_created +function/1/nvim-tree.events.on_file_removed +function/1/nvim-tree.events.on_folder_created +function/1/nvim-tree.events.on_folder_removed +function/1/nvim-tree.events.on_tree_open +function/1/nvim-tree.notify.error +function/1/nvim-tree.notify.info +function/1/nvim-tree.notify.debug +function/1/nvim-tree.notify.warn +function/1/nvim-tree.notify.trace +function/1/nvim-tree.notify.setup +function/2/nvim-tree.explorer.filters.prepare +function/2/nvim-tree.explorer.filters.should_filter +boolean/nvim-tree.explorer.filters.config.filter_custom +boolean/nvim-tree.explorer.filters.config.filter_git_ignored +boolean/nvim-tree.explorer.filters.config.filter_git_clean +boolean/nvim-tree.explorer.filters.config.filter_no_buffer +boolean/nvim-tree.explorer.filters.config.filter_dotfiles +function/1/nvim-tree.explorer.filters.setup +function/1/nvim-tree.explorer.watch.setup +number/nvim-tree.explorer.watch.debounce_delay +function/1/nvim-tree.explorer.watch.create_watcher +number/nvim-tree.explorer.watch.uid +boolean/nvim-tree.explorer.watch.enabled +function/2/nvim-tree.actions.fs.rename-file.rename +boolean/nvim-tree.actions.fs.rename-file.enable_reload +function/1/nvim-tree.actions.fs.rename-file.setup +function/1/nvim-tree.actions.fs.rename-file.fn +function/1/nvim-tree.explorer.node.is_git_ignored +function/3/nvim-tree.explorer.node.update_git_status +function/1/nvim-tree.explorer.node.has_one_child_folder +function/1/nvim-tree.explorer.node.setup +function/1/nvim-tree.explorer.node.node_destroy +function/1/nvim-tree.explorer.node.get_git_status +function/0/nvim-tree.renderer.help.compute_lines +function/2/nvim-tree.explorer.explore.explore +function/1/nvim-tree.explorer.explore.setup +function/1/nvim-tree.explorer.reload.refresh_nodes_for_path +function/1/nvim-tree.explorer.reload.setup +function/1/nvim-tree.explorer.reload.refresh_node +function/3/nvim-tree.explorer.reload.reload +function/1/nvim-tree.actions.tree-modifiers.collapse-all.fn +function/2/nvim-tree.actions.moves.item.fn +function/0/nvim-tree.actions.reloaders.reloaders.reload_git +function/2/nvim-tree.actions.reloaders.reloaders.reload_node_status +function/2/nvim-tree.actions.reloaders.reloaders.reload_explorer +boolean/nvim-tree.config.remove_keymaps +boolean/nvim-tree.config.select_prompts +boolean/nvim-tree.config.actions.remove_file.close_window +boolean/nvim-tree.config.actions.open_file.resize_window +boolean/nvim-tree.config.actions.open_file.quit_on_open +boolean/nvim-tree.config.actions.use_system_clipboard +number/nvim-tree.config.actions.expand_all.max_folder_discovery +string/nvim-tree.config.on_attach +boolean/nvim-tree.config.hijack_cursor +boolean/nvim-tree.config.sync_root_with_cwd +number/nvim-tree.config.notify.threshold +boolean/nvim-tree.config.reload_on_bufenter +boolean/nvim-tree.config.open_on_setup +boolean/nvim-tree.config.open_on_setup_file +string/nvim-tree.config.diagnostics.icons.hint +string/nvim-tree.config.diagnostics.icons.error +string/nvim-tree.config.diagnostics.icons.info +string/nvim-tree.config.diagnostics.icons.warning +number/nvim-tree.config.diagnostics.debounce_delay +boolean/nvim-tree.config.diagnostics.show_on_dirs +boolean/nvim-tree.config.diagnostics.enable +boolean/nvim-tree.config.diagnostics.show_on_open_dirs +boolean/nvim-tree.config.disable_netrw +boolean/nvim-tree.config.hijack_netrw +boolean/nvim-tree.config.view.number +boolean/nvim-tree.config.view.centralize_selection +number/nvim-tree.config.view.debounce_delay +boolean/nvim-tree.config.view.cursorline +number/nvim-tree.config.view.width +boolean/nvim-tree.config.view.hide_root_folder +string/nvim-tree.config.view.side +boolean/nvim-tree.config.view.preserve_window_proportions +boolean/nvim-tree.config.view.relativenumber +string/nvim-tree.config.view.signcolumn +boolean/nvim-tree.config.view.mappings.custom_only +boolean/nvim-tree.config.hijack_unnamed_buffer_when_opening +string/nvim-tree.config.sort_by +boolean/nvim-tree.config.respect_buf_cwd +boolean/nvim-tree.config.filters.git_clean +boolean/nvim-tree.config.filters.no_buffer +boolean/nvim-tree.config.filters.dotfiles +boolean/nvim-tree.config.update_focused_file.update_root +boolean/nvim-tree.config.update_focused_file.enable +boolean/nvim-tree.config.ignore_buffer_on_setup +boolean/nvim-tree.config.auto_reload_on_write +string/nvim-tree.config.live_filter.prefix +boolean/nvim-tree.config.live_filter.always_show_folders +boolean/nvim-tree.config.prefer_startup_root +function/1/nvim-tree.on_enter +function/3/nvim-tree.find_file +boolean/nvim-tree.initialized +function/1/nvim-tree.on_keypress +function/1/nvim-tree.change_dir +function/1/nvim-tree.setup +function/1/nvim-tree.open_replacing_current_buffer +function/0/nvim-tree.open_on_directory +function/1/nvim-tree.open +function/0/nvim-tree.reset_highlight +function/4/nvim-tree.toggle +function/0/nvim-tree.get_config +function/0/nvim-tree.tab_enter +function/1/nvim-tree.resize +function/0/nvim-tree.place_cursor_on_node +boolean/nvim-tree.setup_called +string/nvim-tree.init_root +function/0/nvim-tree.focus +function/2/nvim-tree.change_root +function/1/nvim-tree.actions.moves.sibling.fn +function/2/nvim-tree.explorer.sorters.node_comparator_modification_time +function/2/nvim-tree.explorer.sorters.node_comparator +function/1/nvim-tree.explorer.sorters.setup +string/nvim-tree.explorer.sorters.sort_by +function/2/nvim-tree.explorer.sorters.merge_sort +function/2/nvim-tree.explorer.sorters.node_comparator_extension +function/2/nvim-tree.explorer.sorters.node_comparator_name_case_sensisive +function/2/nvim-tree.explorer.sorters.node_comparator_name_ignorecase +function/1/vscode.theme.set_highlights +function/0/vscode.theme.link_highlight +function/1/cmp.core.prepare +function/1/cmp.core.on_moved +function/2/cmp.core.set_context +function/2/cmp.core.get_sources +function/2/cmp.core.register_source +function/2/cmp.core.unregister_source +function/2/cmp.core.complete +function/2/cmp.core.get_context +function/1/cmp.core.complete_common_string +function/1/cmp.core.reset +function/4/cmp.core.confirm +function/3/cmp.core.autoindent +function/2/cmp.core.on_change +function/3/cmp.core.on_keymap +function/0/cmp.core.new +function/1/cmp.core.suspend +function/2/cmp.core.filter.sync +function/0/cmp.core.filter.stop +boolean/cmp.core.filter.running +number/cmp.core.filter.timeout +function/1/cmp.utils.keymap.delete +function/3/cmp.utils.keymap.listen +function/2/cmp.utils.keymap.get_map +function/3/cmp.utils.keymap.fallback +function/1/cmp.utils.keymap.t +function/2/cmp.utils.keymap.equals +function/3/cmp.utils.keymap.solve +function/1/cmp.utils.keymap.normalize +function/0/cmp.utils.keymap.undobreak +function/5/cmp.utils.keymap.set_map +function/1/cmp.utils.keymap.backspace +function/0/cmp.utils.keymap.undojoin +string/cmp.utils.keymap.to_keymap..1 +string/cmp.utils.keymap.to_keymap..1 +string/cmp.utils.keymap.to_keymap..2 +string/cmp.utils.keymap.to_keymap..3 +string/cmp.utils.keymap.to_keymap..1 +string/cmp.utils.keymap.to_keymap..1 +string/cmp.utils.keymap.to_keymap..1 +function/1/cmp.utils.keymap.indentkeys +function/0/cmp.utils.api.get_screen_cursor +function/0/cmp.utils.api.get_cursor +function/0/cmp.utils.api.get_cursor_before_line +function/0/cmp.utils.api.is_cmdline_mode +function/0/cmp.utils.api.get_mode +function/0/cmp.utils.api.is_insert_mode +function/0/cmp.utils.api.is_visual_mode +function/0/cmp.utils.api.get_current_line +function/0/cmp.utils.api.is_select_mode +function/0/cmp.utils.api.is_suitable_mode +function/2/cmp.utils.cache.key +function/3/cmp.utils.cache.ensure +function/1/cmp.utils.cache.clear +function/2/cmp.utils.cache.get +function/0/cmp.utils.cache.new +function/3/cmp.utils.cache.set +function/1/cmp.source.get_keyword_length +number/cmp.source.SourceStatus.COMPLETED +number/cmp.source.SourceStatus.WAITING +number/cmp.source.SourceStatus.FETCHING +function/3/cmp.source.execute +function/1/cmp.source.get_fetching_time +function/1/cmp.source.get_source_config +function/1/cmp.source.is_available +function/1/cmp.source.get_debug_name +function/0/cmp.source.get_matching_config +function/1/cmp.source.reset +function/2/cmp.source.get_entries +function/3/cmp.source.resolve +function/1/cmp.source.get_position_encoding_kind +function/3/cmp.source.complete +function/1/cmp.source.get_default_replace_range +function/1/cmp.source.get_entry_filter +function/1/cmp.source.get_keyword_pattern +function/1/cmp.source.get_default_insert_range +function/1/cmp.source.get_trigger_characters +function/2/cmp.source.new +function/0/debug.getupvalue +function/0/debug.setupvalue +function/0/debug.upvalueid +function/0/debug.upvaluejoin +function/0/debug.sethook +function/0/debug.getmetatable +function/0/debug.setmetatable +function/0/debug.getfenv +function/0/debug.setfenv +function/0/debug.traceback +function/0/debug.gethook +function/0/debug.debug +function/0/debug.getregistry +function/0/debug.getinfo +function/0/debug.getlocal +function/0/debug.setlocal +function/0/cmp_nvim_lsp.setup +number/cmp_nvim_lsp.client_source_map.1 +function/1/cmp_nvim_lsp.default_capabilities +function/0/cmp_nvim_lsp._on_insert_enter +function/2/cmp_nvim_lsp.update_capabilities +function/2/nvim-tree.git.utils.file_status_to_dir_status +function/1/nvim-tree.git.utils.should_show_untracked +function/1/nvim-tree.git.utils.get_toplevel +function/2/cmp.view.wildmenu_entries_view.select_next_item +function/2/cmp.view.wildmenu_entries_view.select_prev_item +number/cmp.view.wildmenu_entries_view.ns +function/1/cmp.view.wildmenu_entries_view.visible +function/1/cmp.view.wildmenu_entries_view.get_selected_entry +function/1/cmp.view.wildmenu_entries_view.get_active_entry +function/1/cmp.view.wildmenu_entries_view.get_entries +function/0/cmp.view.wildmenu_entries_view.ready +function/1/cmp.view.wildmenu_entries_view.close +function/3/cmp.view.wildmenu_entries_view._select +function/0/cmp.view.wildmenu_entries_view._get_separator +function/1/cmp.view.wildmenu_entries_view.on_change +function/1/cmp.view.wildmenu_entries_view.abort +function/1/cmp.view.wildmenu_entries_view.info +function/1/cmp.view.wildmenu_entries_view.draw +function/1/cmp.view.wildmenu_entries_view.get_offset +function/1/cmp.view.wildmenu_entries_view.get_first_entry +function/3/cmp.view.wildmenu_entries_view.open +function/0/cmp.view.wildmenu_entries_view.new +function/1/nvim-tree.git.runner.run +function/1/nvim-tree.git.runner._run_git_job +function/2/nvim-tree.git.runner._log_raw_output +function/1/nvim-tree.git.runner._wait +function/3/nvim-tree.git.runner._getopts +function/3/nvim-tree.git.runner._parse_status_output +function/3/nvim-tree.git.runner._handle_incoming_data +function/0/package.preload.table.clear +function/0/jit.profile.dumpstack +function/0/jit.profile.stop +function/0/jit.profile.start +function/0/jit.util.funcbc +function/0/jit.util.funck +function/0/jit.util.funcuvname +function/0/jit.util.traceinfo +function/0/jit.util.traceir +function/0/jit.util.tracek +function/0/jit.util.tracesnap +function/0/jit.util.tracemc +function/0/jit.util.traceexitstub +function/0/jit.util.ircalladdr +function/0/jit.util.funcinfo +function/3/vim.keymap.del +function/4/vim.keymap.set +function/2/vim.filetype.findany +function/3/vim.filetype.getlines +function/1/vim.filetype.match +function/1/vim.filetype.add +function/2/vim.filetype.matchregex +function/2/vim.filetype.nextnonblank +function/1/vim._editor.tbl_flatten +function/4/vim._editor.list_extend +function/0/vim._editor._getvar +function/0/vim._editor._setvar +function/1/vim._editor.tbl_deep_extend +function/0/vim._editor.iconv +boolean/vim._editor.type_idx +boolean/vim._editor.val_idx +function/0/vim._editor.schedule +function/0/vim._editor.in_fast_event +function/0/vim._editor.call +function/0/vim._editor.rpcrequest +function/0/vim._editor.rpcnotify +function/0/vim._editor.wait +function/0/vim._editor.ui_attach +function/0/vim._editor.ui_detach +function/0/vim._editor.is_thread +function/1/vim._editor._system +userdata/vim._editor.NIL +function/1/vim._editor.uri_from_bufnr +function/3/vim._editor.split +function/1/vim._editor.schedule_wrap +function/2/vim._editor._expand_pat +function/2/vim._editor.on_key +function/1/vim._editor._expand_pat_get_parts +function/1/vim._editor._on_key +function/0/vim._editor._init_default_mappings +function/5/vim._editor.deprecate +function/4/vim._editor._cs_remote +function/0/vim._editor.pretty_print +function/2/vim._editor.startswith +function/0/vim._editor.empty_dict +function/1/vim._editor._load_package +function/0/vim._editor.register_keystroke_callback +function/3/vim._editor.notify_once +function/3/vim._editor.notify +function/2/vim._editor.defer_fn +function/2/vim._editor.deepcopy +function/5/vim._editor.region +function/2/vim._editor.paste +function/1/vim._editor.uri_from_fname +function/1/vim._editor.uri_to_fname +function/0/vim._editor.version +function/3/vim._editor.gsplit +function/1/vim._editor.funcref +function/1/vim._editor._os_proc_children +function/1/vim._editor._os_proc_info +function/0/vim._editor.diff +function/1/vim._editor.tbl_islist +function/1/vim._editor.tbl_isempty +function/1/vim._editor.defaulttable +function/1/vim._editor.is_callable +function/1/vim._editor.validate +function/2/vim._editor.endswith +function/1/vim._editor.tbl_get +function/0/vim._editor.regex +function/0/vim._editor.str_utf_end +function/0/vim._editor.str_utf_start +function/2/vim._editor.deep_equal +function/0/vim._editor.str_utf_pos +function/1/vim._editor.tbl_keys +function/1/vim._editor.tbl_add_reverse_lookup +function/2/vim._editor.tbl_contains +function/1/vim._editor.tbl_extend +function/2/vim._editor.tbl_filter +function/2/vim._editor.tbl_map +function/1/vim._editor.tbl_values +number/vim._editor.log.levels.INFO +number/vim._editor.log.levels.DEBUG +number/vim._editor.log.levels.TRACE +number/vim._editor.log.levels.WARN +number/vim._editor.log.levels.ERROR +number/vim._editor.log.levels.OFF +function/0/vim._editor._create_ts_parser +function/0/vim._editor._ts_add_language +function/0/vim._editor._ts_has_language +function/0/vim._editor._ts_remove_language +function/0/vim._editor._ts_inspect_language +function/0/vim._editor._ts_parse_query +function/0/vim._editor._ts_get_language_version +function/0/vim._editor._ts_get_minimum_language_version +function/0/vim._editor.stricmp +function/0/vim._editor.str_utfindex +function/0/vim._editor.str_byteindex +function/1/vim._editor.pesc +function/1/vim._editor.trim +function/3/vim._editor.list_slice +function/1/vim._editor.tbl_count +function/1/vim._editor.spairs +function/0/ffi.fill +function/0/ffi.abi +string/ffi.os +function/0/ffi.load +function/0/ffi.string +string/ffi.arch +function/0/ffi.metatype +function/0/ffi.copy +function/0/ffi.sizeof +function/0/ffi.errno +function/0/ffi.gc +userdata/ffi.C +function/0/ffi.cdef +function/0/ffi.cast +function/0/ffi.typeof +function/0/ffi.typeinfo +function/0/ffi.istype +function/0/ffi.alignof +function/0/ffi.offsetof +function/0/ffi.new +function/0/package.preload.vim._init_packages +string/vim.inspect._DESCRIPTION +string/vim.inspect._VERSION +function/2/vim.inspect.inspect +string/vim.inspect._LICENSE +string/vim.inspect._URL +function/0/string.buffer.decode +function/0/string.buffer.encode +function/0/string.buffer.new +function/1/vim.shared.tbl_flatten +function/4/vim.shared.list_extend +function/0/vim.shared._getvar +function/0/vim.shared._setvar +function/1/vim.shared.tbl_deep_extend +function/0/vim.shared.iconv +boolean/vim.shared.type_idx +boolean/vim.shared.val_idx +function/0/vim.shared.schedule +function/0/vim.shared.in_fast_event +function/0/vim.shared.call +function/0/vim.shared.rpcrequest +function/0/vim.shared.rpcnotify +function/0/vim.shared.wait +function/0/vim.shared.ui_attach +function/0/vim.shared.ui_detach +function/0/vim.shared.is_thread +function/1/vim.shared._system +userdata/vim.shared.NIL +function/1/vim.shared.uri_from_bufnr +function/3/vim.shared.split +function/1/vim.shared.schedule_wrap +function/2/vim.shared._expand_pat +function/2/vim.shared.on_key +function/1/vim.shared._expand_pat_get_parts +function/1/vim.shared._on_key +function/0/vim.shared._init_default_mappings +function/5/vim.shared.deprecate +function/4/vim.shared._cs_remote +function/0/vim.shared.pretty_print +function/2/vim.shared.startswith +function/0/vim.shared.empty_dict +function/1/vim.shared._load_package +function/0/vim.shared.register_keystroke_callback +function/3/vim.shared.notify_once +function/3/vim.shared.notify +function/2/vim.shared.defer_fn +function/2/vim.shared.deepcopy +function/5/vim.shared.region +function/2/vim.shared.paste +function/1/vim.shared.uri_from_fname +function/1/vim.shared.uri_to_fname +function/0/vim.shared.version +function/3/vim.shared.gsplit +function/1/vim.shared.funcref +function/1/vim.shared._os_proc_children +function/1/vim.shared._os_proc_info +function/0/vim.shared.diff +function/1/vim.shared.tbl_islist +function/1/vim.shared.tbl_isempty +function/1/vim.shared.defaulttable +function/1/vim.shared.is_callable +function/1/vim.shared.validate +function/2/vim.shared.endswith +function/1/vim.shared.tbl_get +function/0/vim.shared.regex +function/0/vim.shared.str_utf_end +function/0/vim.shared.str_utf_start +function/2/vim.shared.deep_equal +function/0/vim.shared.str_utf_pos +function/1/vim.shared.tbl_keys +function/1/vim.shared.tbl_add_reverse_lookup +function/2/vim.shared.tbl_contains +function/1/vim.shared.tbl_extend +function/2/vim.shared.tbl_filter +function/2/vim.shared.tbl_map +function/1/vim.shared.tbl_values +function/0/vim.shared._create_ts_parser +function/0/vim.shared._ts_add_language +function/0/vim.shared._ts_has_language +function/0/vim.shared._ts_remove_language +function/0/vim.shared._ts_inspect_language +function/0/vim.shared._ts_parse_query +function/0/vim.shared._ts_get_language_version +function/0/vim.shared._ts_get_minimum_language_version +function/0/vim.shared.stricmp +function/0/vim.shared.str_utfindex +function/0/vim.shared.str_byteindex +function/1/vim.shared.pesc +function/1/vim.shared.trim +function/3/vim.shared.list_slice +function/1/vim.shared.tbl_count +function/1/vim.shared.spairs +function/1/vim.F.ok_or_nil +function/1/vim.F.npcall +function/1/vim.F.nil_wrap +function/0/vim.F.pack_len +function/1/vim.F.unpack_len +function/2/vim.F.if_nil +function/0/package.preload.vim._meta +function/0/package.preload.table.new +function/0/package.loadlib +function/0/package.searchpath +function/0/package.seeall +function/0/package.loaders.1 +function/1/package.loaders.2 +function/1/package.loaders.3 +function/0/package.loaders.4 +function/0/package.loaders.5 +function/0/package.loaders.6 +string/package.path +string/package.cpath +function/2/dump +function/0/module +function/0/require +function/0/assert +function/1/cmp.utils.feedkeys.call.run +function/0/type +function/0/next +function/0/pairs +function/0/ipairs +function/0/getmetatable +function/0/setmetatable +function/0/getfenv +function/0/setfenv +function/0/rawget +function/0/rawset +function/0/rawequal +function/0/unpack +function/0/select +function/0/tonumber +function/0/tostring diff --git a/home/common/nvim/vim-opts.nix b/home/common/nvim/vim-opts.nix new file mode 100644 index 0000000..6f2fe3c --- /dev/null +++ b/home/common/nvim/vim-opts.nix @@ -0,0 +1,62 @@ +{ lib, raw, call }: let defs = map (line: + if lib.hasPrefix "function/" line then let split = lib.splitString "/" (lib.removePrefix "function/" line); in { + type = "function"; + arity = lib.toInt (builtins.elemAt split 0); + value = builtins.elemAt split 1; + } else if lib.hasPrefix "string/" line then { + type = "string"; + value = lib.removePrefix "string/" line; + } else if lib.hasPrefix "boolean/" line then { + type = "boolean"; + value = lib.removePrefix "boolean/" line; + } else if lib.hasPrefix "number/" line then { + type = "number"; + value = lib.removePrefix "number/" line; + } else { + type = "ignore"; + value = "____ignore.___ignore"; + }) (lib.splitString "\n" (builtins.readFile ./vim-lua.txt)); + process' = val: ( + if val.type == "function" then ( + #if val.arity == 0 then + args: if args == "GET_INFO" then val else call (raw val.value) args + #else if val.arity == 1 then (a: if a == "GET_INFO" then val else call (raw val.value) [a]) + #else (a: if a == "GET_INFO" then val else call (raw val.value) a) + ) else raw val.value + ); + process = val: lib.setAttrByPath (lib.splitString "." val.value) (process' val); + processOpt = o: val: lib.setAttrByPath ["vim" o val] (raw "vim.${o}.${val}"); + processVar = val: + if lib.hasPrefix "b:" val then lib.setAttrByPath ["vim" "b" (lib.removePrefix "b:" val)] (raw "vim.b.${val}") + else if lib.hasPrefix "v:" val then lib.setAttrByPath ["vim" "v" (lib.removePrefix "v:" val)] (raw "vim.v.${val}") + else if lib.hasPrefix "w:" val then lib.setAttrByPath ["vim" "w" (lib.removePrefix "w:" val)] (raw "vim.w.${val}") + else if lib.hasPrefix "t:" val then lib.setAttrByPath ["vim" "t" (lib.removePrefix "t:" val)] (raw "vim.t.${val}") + else if lib.hasPrefix "v:" val then lib.setAttrByPath ["vim" "v" (lib.removePrefix "v:" val)] (raw "vim.v.${val}") + else lib.setAttrByPath ["vim" "g" val] (raw "vim.g.${val}"); + setPath = path: key: val: if builtins.isAttrs val + then (builtins.mapAttrs (setPath "${path}${key}.") val) // { __kind = "var"; _name = "${path}${key}"; } + else val; + opts = (lib.splitString "\n" (builtins.readFile ./vim-opts.txt)); + vars = (lib.splitString "\n" (builtins.readFile ./vim-vars.txt)); + zip = x: if x == [] then {} else lib.recursiveUpdate (zip (builtins.tail x)) (builtins.head x); + patch = builtins.mapAttrs (k: v: if k == "vim" then v // { + inspect = process' { + type = "function"; + arity = 2; + value = "vim.inspect"; + }; + cmd = process' { + type = "function"; + arity = 1; + value = "vim.cmd"; + }; + } else v); +in + patch (builtins.mapAttrs (setPath "") + (zip ( + (map process defs) + ++ (map process (map (x: x // {value = "vim" + (lib.removePrefix "vim.shared" x.value); }) (builtins.filter ({value,...}: lib.hasPrefix "vim.shared" value) defs))) + ++ (map (processOpt "o") opts) + ++ (map (processOpt "opt") opts) + ++ (map processVar vars) + ))) diff --git a/home/common/nvim/vim-opts.txt b/home/common/nvim/vim-opts.txt new file mode 100644 index 0000000..75a5d34 --- /dev/null +++ b/home/common/nvim/vim-opts.txt @@ -0,0 +1,354 @@ +all +aleph +arabic +arabicshape +allowrevins +ambiwidth +autochdir +autoindent +autoread +autowrite +autowriteall +background +backspace +backup +backupcopy +backupdir +backupext +backupskip +belloff +binary +bomb +breakat +breakindent +breakindentopt +bufhidden +buflisted +buftype +casemap +cdhome +cdpath +cedit +channel +charconvert +cindent +cinkeys +cinoptions +cinwords +cinscopedecls +clipboard +cmdheight +cmdwinheight +colorcolumn +columns +comments +commentstring +compatible +complete +concealcursor +conceallevel +completefunc +completeopt +confirm +copyindent +cpoptions +cscopepathcomp +cscopeprg +cscopequickfix +cscoperelative +cscopetag +cscopetagorder +cscopeverbose +cursorbind +cursorcolumn +cursorline +cursorlineopt +debug +define +delcombine +dictionary +diff +diffexpr +diffopt +digraph +directory +display +eadirection +edcompatible +emoji +encoding +endofline +equalalways +equalprg +errorbells +errorfile +errorformat +eventignore +expandtab +exrc +fileencoding +fileencodings +fileformat +fileformats +fileignorecase +filetype +fillchars +fixendofline +foldclose +foldcolumn +foldenable +foldexpr +foldignore +foldlevel +foldlevelstart +foldmarker +foldmethod +foldminlines +foldnestmax +foldopen +foldtext +formatexpr +formatoptions +formatlistpat +formatprg +fsync +gdefault +grepformat +grepprg +guicursor +guifont +guifontwide +helpfile +helpheight +helplang +hidden +highlight +history +hkmap +hkmapp +hlsearch +icon +iconstring +ignorecase +iminsert +imsearch +inccommand +include +includeexpr +incsearch +indentexpr +indentkeys +infercase +insertmode +isfname +isident +iskeyword +isprint +joinspaces +jumpoptions +keymap +keymodel +keywordprg +langmap +langmenu +langnoremap +langremap +laststatus +lazyredraw +linebreak +lines +linespace +lisp +lispwords +list +listchars +loadplugins +magic +makeef +makeencoding +makeprg +matchpairs +matchtime +maxcombine +maxfuncdepth +maxmapdepth +maxmempattern +menuitems +mkspellmem +modeline +modelineexpr +modelines +modifiable +modified +more +mouse +mousefocus +mousemodel +mousemoveevent +mousescroll +mousetime +nrformats +number +numberwidth +omnifunc +operatorfunc +packpath +paragraphs +paste +pastetoggle +patchexpr +patchmode +path +preserveindent +previewheight +previewwindow +printdevice +printencoding +printexpr +printfont +printheader +printmbcharset +printmbfont +printoptions +prompt +pumblend +pumheight +pumwidth +pyxversion +quickfixtextfunc +quoteescape +readonly +redrawdebug +redrawtime +regexpengine +relativenumber +remap +report +revins +rightleft +rightleftcmd +ruler +rulerformat +runtimepath +scroll +scrollback +scrollbind +scrolljump +scrolloff +scrollopt +sections +secure +selection +selectmode +sessionoptions +shada +shadafile +shell +shellcmdflag +shellpipe +shellquote +shellredir +shelltemp +shellxquote +shellxescape +shiftround +shiftwidth +shortmess +showbreak +showcmd +showfulltag +showmatch +showmode +showtabline +sidescroll +sidescrolloff +signcolumn +smartcase +smartindent +smarttab +softtabstop +spell +spellcapcheck +spellfile +spelllang +spellsuggest +spelloptions +splitbelow +splitright +startofline +statusline +suffixes +suffixesadd +swapfile +switchbuf +synmaxcol +syntax +tagfunc +tabline +tabpagemax +tabstop +tagbsearch +tagcase +taglength +tagrelative +tags +tagstack +termbidi +termguicolors +termpastefilter +terse +textwidth +thesaurus +thesaurusfunc +tildeop +timeout +timeoutlen +title +titlelen +titleold +titlestring +ttimeout +ttimeoutlen +ttyfast +undodir +undofile +undolevels +undoreload +updatecount +updatetime +varsofttabstop +vartabstop +verbose +verbosefile +viewdir +viewoptions +virtualedit +visualbell +warn +whichwrap +wildchar +wildcharm +wildignore +wildignorecase +wildmenu +wildmode +wildoptions +winaltkeys +winbar +winblend +winhighlight +window +winheight +winfixheight +winfixwidth +winminheight +winminwidth +winwidth +wrap +wrapmargin +wrapscan +write +writeany +writebackup +writedelay + diff --git a/home/common/nvim/vim-update.py b/home/common/nvim/vim-update.py new file mode 100644 index 0000000..6a3bd87 --- /dev/null +++ b/home/common/nvim/vim-update.py @@ -0,0 +1,23 @@ +import os, json +d = os.path.dirname(os.path.realpath(__file__)) +j = lambda x: os.path.join(d, x) +x = open(j("vim-lua.txt"),'rt').read().split('\n') +y = open(j("vim-opts.txt"),'rt').read().split('\n') + +a = {} +def add(w, k, v): + if w.get(k[0]) is None: + w[k[0]] = {} + if len(k) == 1: + w[k[0]] = v + else: + add(w[k[0]], k[1:], v) + +for w in x: + if w: + if w.startswith('function/'): + t, ar, n = w.split('/') + add(a, {'type'}) + else: + t, n = w.split('/') + diff --git a/home/common/nvim/vim-vars.txt b/home/common/nvim/vim-vars.txt new file mode 100644 index 0000000..789009c --- /dev/null +++ b/home/common/nvim/vim-vars.txt @@ -0,0 +1,140 @@ +NvimTreeRequired +NvimTreeSetup +b:autopairs_keymaps +b:changedtick +b:nvim-autopairs +colors_name +did_indent_on +did_load_filetypes +did_load_ftplugin +ft_ignore_pat +loaded_2html_plugin +loaded_clipboard_provider +loaded_cmp +loaded_devicons +loaded_gzip +loaded_man +loaded_matchit +loaded_matchparen +loaded_netrw +loaded_netrwPlugin +loaded_node_provider +loaded_python_provider +loaded_remote_plugins +loaded_shada_plugin +loaded_sleuth +loaded_spellfile_plugin +loaded_tarPlugin +loaded_tutor_mode_plugin +loaded_zipPlugin +lspconfig +lua_subversion +lua_version +markdown_fenced_languages +markdown_minlines +matchparen_insert_timeout +matchparen_timeout +nvim_web_devicons +python3_host_prog +ruby_host_prog +syntax_on +system_remote_plugins +v:_null_blob +v:_null_dict +v:_null_list +v:_null_string +v:argv +v:beval_bufnr +v:beval_col +v:beval_lnum +v:beval_text +v:beval_winid +v:beval_winnr +v:char +v:charconvert_from +v:charconvert_to +v:cmdarg +v:cmdbang +v:collate +v:completed_item +v:count +v:count1 +v:ctype +v:dying +v:echospace +v:errmsg +v:errors +v:event +v:exception +v:exiting +v:false +v:fcs_choice +v:fcs_reason +v:fname +v:fname_diff +v:fname_in +v:fname_new +v:fname_out +v:folddashes +v:foldend +v:foldlevel +v:foldstart +v:hlsearch +v:insertmode +v:key +v:lang +v:lc_time +v:lnum +v:lua +v:mouse_col +v:mouse_lnum +v:mouse_win +v:mouse_winid +v:msgpack_types +v:null +v:numbermax +v:numbermin +v:numbersize +v:oldfiles +v:operator +v:option_command +v:option_new +v:option_old +v:option_oldglobal +v:option_oldlocal +v:option_type +v:prevcount +v:profiling +v:progname +v:progpath +v:register +v:scrollstart +v:searchforward +v:servername +v:shell_error +v:statusmsg +v:stderr +v:swapchoice +v:swapcommand +v:swapname +v:t_blob +v:t_bool +v:t_dict +v:t_float +v:t_func +v:t_list +v:t_number +v:t_string +v:termresponse +v:testing +v:this_session +v:throwpoint +v:true +v:val +v:version +v:vim_did_enter +v:warningmsg +v:windowid +vimsyn_embed +zipPlugin_ext + diff --git a/home/common/vim.nix b/home/common/vim.nix deleted file mode 100644 index 6da32bc..0000000 --- a/home/common/vim.nix +++ /dev/null @@ -1,349 +0,0 @@ -{ config, pkgs, ... }: -{ - imports = [ ./options.nix ]; - programs.neovim = { - enable = true; - defaultEditor = true; - package = pkgs.neovim-unwrapped; - extraPackages = with pkgs; [ - rust-analyzer - nodePackages_latest.bash-language-server shellcheck - nodePackages_latest.typescript-language-server - nodePackages_latest.svelte-language-server - clang-tools - nodePackages_latest.vscode-langservers-extracted - nil - marksman - taplo - python3Packages.python-lsp-server - ]; - # extraPython3Packages = pyPkgs: with pyPkgs; [ python-lsp-server ]; - extraConfig = '' - syntax on - au FileType markdown set colorcolumn=73 textwidth=72 - au FileType gitcommit set colorcolumn=73 - highlight NormalFloat guibg=NONE - au BufReadPre * set foldmethod=syntax - au BufReadPost * folddoc foldopen! - autocmd BufReadPost * if @% !~# '\.git[\/\\]COMMIT_EDITMSG$' && line("'\"") > 1 && line("'\"") <= line("$") | exe "normal! g`\"" | endif - ''; - viAlias = true; - vimAlias = true; - vimdiffAlias = true; - plugins = - let lua = (s: '' - lua << EOF - ${s} - EOF - ''); - in with pkgs.vimPlugins; [ - vim-svelte - # TODO remove on next nvim update (0.8.3/0.9) - vim-nix - { plugin = pkgs.vimUtils.buildVimPluginFrom2Nix { - pname = "vscode-nvim"; - version = "2023-02-10"; - src = pkgs.fetchFromGitHub { - owner = "Mofiqul"; - repo = "vscode.nvim"; - rev = "db9ee339b5556aa832ca58871fd18f9467a18520"; - sha256 = "sha256-X2IgIjO5NNq7vJdl09hBY1TFqHlsfF1xfllKr4osILI="; - }; - }; - config = lua '' - require("vscode").setup({ - transparent = true, - color_overrides = { - vscGray = "#745b5f", - vscViolet = "#${config.colors.magenta}", - vscBlue = "#6ddfd8", - vscDarkBlue = "#${config.colors.blue}", - vscGreen = "#${config.colors.green}", - vscBlueGreen = "#73bf88", - vscLightGreen = "#6acf6e", - vscRed = "#${config.colors.red}", - vscOrange = "#e89666", - vscLightRed = "#e64e4e", - vscYellowOrange = "#e8b166", - vscYellow = "#${config.colors.yellow}", - vscPink = "#cf83c4", - }, - }) - ''; } - { plugin = nvim-web-devicons; - config = lua '' - require'nvim-web-devicons'.setup { - } - ''; } - { plugin = nvim-tree-lua; - config = lua '' - vim.g.loaded_netrw = 1 - vim.g.loaded_netrwPlugin = 1 - vim.opt.termguicolors = true - require("nvim-tree").setup({ - -- :help nvim-tree-setup - }) - local opts = { noremap=true, silent=true } - vim.keymap.set('n', '', require("nvim-tree.api").tree.toggle, opts) - require("which-key").register({[''] = { - require("nvim-tree.api").tree.toggle, 'Toggle NvimTree' - }}, {mode='n', noremap=true, silent=true}) - ''; } - vim-sleuth - luasnip - { plugin = nvim-cmp; - config = lua '' - local cmp = require('cmp') - local function border(hl_name) - return { - { "╭", hl_name }, - { "─", hl_name }, - { "╮", hl_name }, - { "│", hl_name }, - { "╯", hl_name }, - { "─", hl_name }, - { "╰", hl_name }, - { "│", hl_name }, - } - end - cmp.setup { - snippet = { - expand = function(args) - require('luasnip').lsp_expand(args.body) - end, - }, - view = { - - }, - window = { - completion = { - border = border "CmpBorder", - winhighlight = "Normal:CmpPmenu,CursorLine:PmenuSel,Search:None", - }, - documentation = { - border = border "CmpDocBorder", - }, - }, - formatting = { - format = function(_, vim_item) - local icons = require("lspkind") - vim_item.kind = string.format("%s %s", icons[vim_item.kind], vim_item.kind) - return vim_item - end, - }, - mapping = { - [''] = cmp.mapping.select_prev_item(), - [''] = cmp.mapping.select_next_item(), - [''] = cmp.mapping.complete(), - [''] = cmp.mapping.close(), - [''] = cmp.mapping.confirm { - behavior = cmp.ConfirmBehavior.Replace, - select = false, - }, - [''] = cmp.mapping(function(fallback) - if cmp.visible() then - cmp.select_next_item() - elseif require("luasnip").expand_or_jumpable() then - vim.fn.feedkeys(vim.api.nvim_replace_termcodes('luasnip-expand-or-jump', true, true, true), "") - else - fallback() - end - end, { - "i", - "s", - }), - [''] = cmp.mapping(function(fallback) - if cmp.visible() then - cmp.select_prev_item() - elseif require('luasnip').jumpable(-1) then - vim.fn.feedkeys(vim.api.nvim_replace_termcodes('luasnip-jump-prev', true, true, true), "") - else - fallback() - end - end, { - "i", - "s", - }), - }, - sources = cmp.config.sources({ - { name = 'nvim_lsp' }, - { name = 'luasnip' }, - }), - } - ''; } - lspkind-nvim - cmp_luasnip - cmp-nvim-lsp - { plugin = nvim-autopairs; - config = lua '' - require('nvim-autopairs').setup({ - disable_filetype = { "TelescopePrompt" , "vim" }, - }) - local cmp_autopairs = require('nvim-autopairs.completion.cmp') - local cmp = require('cmp') - cmp.event:on( - 'confirm_done', - cmp_autopairs.on_confirm_done() - ) - ''; } - { plugin = comment-nvim; - config = lua '' - require('Comment').setup() - local opts = { noremap=true, silent=true } - vim.keymap.set('n', '/', require("Comment.api").toggle.linewise.current, opts) - vim.keymap.set('v', '/', "lua require('Comment.api').toggle.linewise(vim.fn.visualmode())", opts) - require("which-key").register({['/'] = { - require("Comment.api").toggle.linewise.current, 'Comment current line' - }}, {mode='n', noremap=true, silent=true}) - require("which-key").register({['/'] = { - "lua require('Comment.api').toggle.linewise(vim.fn.visualmode())", 'Comment current line' - }}, {mode='v', noremap=true, silent=true}) - - ''; } - { plugin = nvim-lspconfig; - config = lua '' - -- Mappings. - -- See `:help vim.diagnostic.*` for documentation on any of the below functions - local opts = { noremap=true, silent=true } - vim.keymap.set('n', 'e', vim.diagnostic.open_float, opts) - vim.keymap.set('n', '[d', vim.diagnostic.goto_prev, opts) - vim.keymap.set('n', ']d', vim.diagnostic.goto_next, opts) - vim.keymap.set('n', 'q', vim.diagnostic.setloclist, opts) - require("which-key").register({ - ['e'] = { vim.diagnostic.open_float, 'Show diagnostics in a floating window.' }, - ['[d'] = { vim.diagnostic.goto_prev, 'Move to the previous diagnostic in the current buffer.' }, - [']d'] = { vim.diagnostic.goto_next, 'Get the next diagnostic closest to the cursor position.' }, - ['q'] = { vim.diagnostic.setloclist, 'Add buffer diagnostics to the location list.' }, - }, {mode='n', noremap=true, silent=true}) - - -- Use an on_attach function to only map the following keys - -- after the language server attaches to the current buffer - local on_attach = function(client, bufnr) - -- Enable completion triggered by - vim.api.nvim_buf_set_option(bufnr, 'omnifunc', 'v:lua.vim.lsp.omnifunc') - - -- Mappings. - -- See `:help vim.lsp.*` for documentation on any of the below functions - local bufopts = { noremap=true, silent=true, buffer=bufnr } - vim.keymap.set('n', 'gD', vim.lsp.buf.declaration, bufopts) - vim.keymap.set('n', 'gd', vim.lsp.buf.definition, bufopts) - vim.keymap.set('n', 'K', vim.lsp.buf.hover, bufopts) - vim.keymap.set('n', 'gi', vim.lsp.buf.implementation, bufopts) - vim.keymap.set('n', '', vim.lsp.buf.signature_help, bufopts) - vim.keymap.set('n', 'wa', vim.lsp.buf.add_workspace_folder, bufopts) - vim.keymap.set('n', 'wr', vim.lsp.buf.remove_workspace_folder, bufopts) - vim.keymap.set('n', 'wl', function() - print(vim.inspect(vim.lsp.buf.list_workspace_folders())) - end, bufopts) - vim.keymap.set('n', 'D', vim.lsp.buf.type_definition, bufopts) - vim.keymap.set('n', 'rn', vim.lsp.buf.rename, bufopts) - vim.keymap.set('n', 'ca', vim.lsp.buf.code_action, bufopts) - vim.keymap.set('n', 'gr', vim.lsp.buf.references, bufopts) - vim.keymap.set('n', 'f', function() vim.lsp.buf.format { async = true } end, bufopts) - require("which-key").register({ - ['gD'] = { vim.lsp.buf.declaration, 'Jumps to the declaration of the symbol under the cursor.' }, - ['gd'] = { vim.lsp.buf.definition, 'Jumps to the definition of the symbol under the cursor.' }, - ['K'] = { vim.lsp.buf.hover, 'Displays hover information about the symbol under the cursor in a floating window.' }, - ['gi'] = { vim.lsp.buf.implementation, 'Lists all the implementations for the symbol under the cursor in the quickfix window.' }, - [''] = { vim.lsp.buf.signature_help, 'Displays signature information about the symbol under the cursor in a floating window.' }, - ['wa'] = { vim.lsp.buf.add_workspace_folder, 'Add a folder to the workspace folders.' }, - ['wr'] = { vim.lsp.buf.remove_workspace_folder, 'Remove a folder from the workspace folders.' }, - ['wl'] = { function() - print(vim.inspect(vim.lsp.buf.list_workspace_folders())) - end, 'List workspace folders.' }, - ['D'] = { vim.lsp.buf.type_definition, 'Jumps to the definition of the type of the symbol under the cursor.' }, - ['rn'] = { vim.lsp.buf.rename, 'Rename old_fname to new_fname' }, - ['ca'] = { vim.lsp.buf.code_action, 'Selects a code action available at the current cursor position.' }, - ['gr'] = { vim.lsp.buf.references, 'Lists all the references to the symbol under the cursor in the quickfix window.' }, - ['f'] = { function() - vim.lsp.buf.format { async = true } - end, 'Formats a buffer.' }, - }, {mode='n', noremap=true, silent=true, buffer=bufnr}) - end - - local lsp_flags = { - -- This is the default in Nvim 0.7+ - debounce_text_changes = 150, - } - local capabilities = vim.tbl_extend( - 'keep', - vim.lsp.protocol.make_client_capabilities(), - require('cmp_nvim_lsp').default_capabilities() - ); - -- see https://github.com/neovim/nvim-lspconfig/blob/master/doc/server_configurations.md - require'lspconfig'.bashls.setup{ - on_attach = on_attach, - flags = lsp_flags, - capabilities = capabilities, - } - require'lspconfig'.clangd.setup{ - -- usually requires compile_flags.json - on_attach = on_attach, - flags = lsp_flags, - capabilities = capabilities, - } - require'lspconfig'.pylsp.setup{ - -- https://github.com/python-lsp/python-lsp-server/blob/develop/CONFIGURATION.md - on_attach = on_attach, - flags = lsp_flags, - capabilities = capabilities, - } - require'lspconfig'.svelte.setup{ - on_attach = on_attach, - flags = lsp_flags, - capabilities = capabilities, - } - require'lspconfig'.html.setup{ - on_attach = on_attach, - flags = lsp_flags, - capabilities = capabilities, - } - require'lspconfig'.cssls.setup{ - on_attach = on_attach, - flags = lsp_flags, - capabilities = capabilities, - } - require'lspconfig'.tsserver.setup{ - on_attach = on_attach, - flags = lsp_flags, - capabilities = capabilities, - } - require'lspconfig'.jsonls.setup{ - on_attach = on_attach, - flags = lsp_flags, - capabilities = capabilities, - } - require'lspconfig'.nil_ls.setup{ - on_attach = on_attach, - flags = lsp_flags, - capabilities = capabilities, - } - require'lspconfig'.taplo.setup{ - on_attach = on_attach, - flags = lsp_flags, - capabilities = capabilities, - } - require'lspconfig'.marksman.setup{ - on_attach = on_attach, - flags = lsp_flags, - capabilities = capabilities, - } - require'lspconfig'.rust_analyzer.setup{ - on_attach = on_attach, - flags = lsp_flags, - capabilities = capabilities, - -- Server-specific settings... - settings = { - ["rust-analyzer"] = {} - } - } - ''; } - { plugin = which-key-nvim; - config = lua '' - vim.o.timeout = true - vim.o.timeoutlen = 500 - require("which-key").setup { } - ''; } - ]; - }; -} diff --git a/home/common/waybar.nix b/home/common/waybar.nix index cbabbd9..faae112 100644 --- a/home/common/waybar.nix +++ b/home/common/waybar.nix @@ -116,4 +116,7 @@ }]; style = ./waybar.css; }; + home.packages = with pkgs; [ + playerctl + ]; } diff --git a/home/hosts/nixmsi.nix b/home/hosts/nixmsi.nix index f8d0081..fabccb9 100644 --- a/home/hosts/nixmsi.nix +++ b/home/hosts/nixmsi.nix @@ -4,7 +4,7 @@ ../common/general.nix ../common/firefox ../common/i3-sway.nix - ../common/vim.nix + ../common/nvim ../common/helix.nix ../common/kakoune.nix ]; @@ -51,6 +51,9 @@ STEAM_EXTRA_COMPAT_TOOLS_PATHS = "${proton-ge}"; }; home.packages = with pkgs; [ + (ghidra.overrideAttrs (old: { + patches = old.patches ++ [ ../common/ghidra-stdcall.patch ]; + })) cutter openrgb piper steam-run steam osu-lazer-bin taisei diff --git a/system/hosts/nixmsi.nix b/system/hosts/nixmsi.nix index 46defe1..b60b63c 100644 --- a/system/hosts/nixmsi.nix +++ b/system/hosts/nixmsi.nix @@ -274,6 +274,7 @@ in { experimental-features = nix-command flakes ''; }; + systemd.services.nix-daemon.serviceConfig.LimitSTACKSoft = "infinity"; documentation.dev.enable = true;