Vim

24 files changed, 10526 insertions, 0 deletions

diff --git a/vim/pack/downloads/opt/lsp/autoload/lsp/buffer.vim b/vim/pack/downloads/opt/lsp/autoload/lsp/buffer.vim
new file mode 100644
index 0000000..5a07654
--- /dev/null
+++ b/vim/pack/downloads/opt/lsp/autoload/lsp/buffer.vim
@@ -0,0 +1,194 @@
+vim9script
+
+# Functions for managing the per-buffer LSP server information
+
+import './util.vim'
+
+# A buffer can have one or more attached language servers.  The
+# "bufnrToServers" Dict contains the list of language servers attached to a
+# buffer. The buffer number is the key for the "bufnrToServers" Dict.  The
+# value is the List of attached language servers.
+var bufnrToServers: dict<list<dict<any>>> = {}
+
+# Add "lspserver" to "bufnrToServers" map for buffer "bnr".
+export def BufLspServerSet(bnr: number, lspserver: dict<any>)
+  if !bufnrToServers->has_key(bnr)
+    bufnrToServers[bnr] = []
+  endif
+
+  bufnrToServers[bnr]->add(lspserver)
+enddef
+
+# Remove "lspserver" from "bufnrToServers" map for buffer "bnr".
+export def BufLspServerRemove(bnr: number, lspserver: dict<any>)
+  if !bufnrToServers->has_key(bnr)
+    return
+  endif
+
+  var servers: list<dict<any>> = bufnrToServers[bnr]
+  servers = servers->filter((key, srv) => srv.id != lspserver.id)
+
+  if servers->empty()
+    bufnrToServers->remove(bnr)
+  else
+    bufnrToServers[bnr] = servers
+  endif
+enddef
+
+var SupportedCheckFns = {
+  callHierarchy: (lspserver) => lspserver.isCallHierarchyProvider,
+  codeAction: (lspserver) => lspserver.isCodeActionProvider,
+  codeLens: (lspserver) => lspserver.isCodeLensProvider,
+  completion: (lspserver) => lspserver.isCompletionProvider,
+  declaration: (lspserver) => lspserver.isDeclarationProvider,
+  definition: (lspserver) => lspserver.isDefinitionProvider,
+  documentFormatting: (lspserver) => lspserver.isDocumentFormattingProvider,
+  documentHighlight: (lspserver) => lspserver.isDocumentHighlightProvider,
+  documentSymbol: (lspserver) => lspserver.isDocumentSymbolProvider,
+  foldingRange: (lspserver) => lspserver.isFoldingRangeProvider,
+  hover: (lspserver) => lspserver.isHoverProvider,
+  implementation: (lspserver) => lspserver.isImplementationProvider,
+  inlayHint: (lspserver) => lspserver.isInlayHintProvider ||
+					lspserver.isClangdInlayHintsProvider,
+  references: (lspserver) => lspserver.isReferencesProvider,
+  rename: (lspserver) => lspserver.isRenameProvider,
+  selectionRange: (lspserver) => lspserver.isSelectionRangeProvider,
+  semanticTokens: (lspserver) => lspserver.isSemanticTokensProvider,
+  signatureHelp: (lspserver) => lspserver.isSignatureHelpProvider,
+  typeDefinition: (lspserver) => lspserver.isTypeDefinitionProvider,
+  typeHierarchy: (lspserver) => lspserver.isTypeHierarchyProvider,
+  workspaceSymbol: (lspserver) => lspserver.isWorkspaceSymbolProvider
+}
+
+# Returns the LSP server for the buffer "bnr".  If "feature" is specified,
+# then returns the LSP server that provides the "feature".
+# Returns an empty dict if the server is not found.
+export def BufLspServerGet(bnr: number, feature: string = null_string): dict<any>
+  if !bufnrToServers->has_key(bnr)
+    return {}
+  endif
+
+  if bufnrToServers[bnr]->empty()
+    return {}
+  endif
+
+  if feature == null_string
+    return bufnrToServers[bnr][0]
+  endif
+
+  if !SupportedCheckFns->has_key(feature)
+    # If this happns it is a programming error, and should be fixed in the
+    # source code
+    :throw $'Error: ''{feature}'' is not a valid feature'
+  endif
+
+  var SupportedCheckFn = SupportedCheckFns[feature]
+
+  var possibleLSPs: list<dict<any>> = []
+
+  for lspserver in bufnrToServers[bnr]
+    if !lspserver.ready || !SupportedCheckFn(lspserver)
+      continue
+    endif
+
+    possibleLSPs->add(lspserver)
+  endfor
+
+  if possibleLSPs->empty()
+    return {}
+  endif
+
+  # LSP server is configured to be a provider for "feature"
+  for lspserver in possibleLSPs
+    var has_feature: bool = lspserver.features->get(feature, false)
+    if has_feature
+      return lspserver
+    endif
+  endfor
+
+  # Return the first LSP server that supports "feature" and doesn't have it
+  # disabled
+  for lspserver in possibleLSPs
+    if lspserver.featureEnabled(feature)
+      return lspserver
+    endif
+  endfor
+
+  return {}
+enddef
+
+# Returns the LSP server for the buffer "bnr" and with ID "id". Returns an empty
+# dict if the server is not found.
+export def BufLspServerGetById(bnr: number, id: number): dict<any>
+  if !bufnrToServers->has_key(bnr)
+    return {}
+  endif
+
+  for lspserver in bufnrToServers[bnr]
+    if lspserver.id == id
+      return lspserver
+    endif
+  endfor
+
+  return {}
+enddef
+
+# Returns the LSP servers for the buffer "bnr". Returns an empty list if the
+# servers are not found.
+export def BufLspServersGet(bnr: number): list<dict<any>>
+  if !bufnrToServers->has_key(bnr)
+    return []
+  endif
+
+  return bufnrToServers[bnr]
+enddef
+
+# Returns the LSP server for the current buffer with the optionally "feature".
+# Returns an empty dict if the server is not found.
+export def CurbufGetServer(feature: string = null_string): dict<any>
+  return BufLspServerGet(bufnr(), feature)
+enddef
+
+# Returns the LSP servers for the current buffer. Returns an empty list if the
+# servers are not found.
+export def CurbufGetServers(): list<dict<any>>
+  return BufLspServersGet(bufnr())
+enddef
+
+export def BufHasLspServer(bnr: number): bool
+  var lspserver = BufLspServerGet(bnr)
+
+  return !lspserver->empty()
+enddef
+
+# Returns the LSP server for the current buffer with the optinally "feature" if
+# it is running and is ready.
+# Returns an empty dict if the server is not found or is not ready.
+export def CurbufGetServerChecked(feature: string = null_string): dict<any>
+  var fname: string = @%
+  if fname->empty() || &filetype->empty()
+    return {}
+  endif
+
+  var lspserver: dict<any> = CurbufGetServer(feature)
+  if lspserver->empty()
+    if feature == null_string
+      util.ErrMsg($'Language server for "{&filetype}" file type is not found')
+    else
+      util.ErrMsg($'Language server for "{&filetype}" file type supporting "{feature}" feature is not found')
+    endif
+    return {}
+  endif
+  if !lspserver.running
+    util.ErrMsg($'Language server for "{&filetype}" file type is not running')
+    return {}
+  endif
+  if !lspserver.ready
+    util.ErrMsg($'Language server for "{&filetype}" file type is not ready')
+    return {}
+  endif
+
+  return lspserver
+enddef
+
+# vim: tabstop=8 shiftwidth=2 softtabstop=2
diff --git a/vim/pack/downloads/opt/lsp/autoload/lsp/callhierarchy.vim b/vim/pack/downloads/opt/lsp/autoload/lsp/callhierarchy.vim
new file mode 100644
index 0000000..aca6a55
--- /dev/null
+++ b/vim/pack/downloads/opt/lsp/autoload/lsp/callhierarchy.vim
@@ -0,0 +1,194 @@
+vim9script
+
+# Functions for dealing with call hierarchy (incoming/outgoing calls)
+
+import './util.vim'
+import './buffer.vim' as buf
+
+# Jump to the location of the symbol under the cursor in the call hierarchy
+# tree window.
+def CallHierarchyItemJump()
+  var item: dict<any> = w:LspCallHierItemMap[line('.')].item
+  util.JumpToLspLocation(item, '')
+enddef
+
+# Refresh the call hierarchy tree for the symbol at index "idx".
+def CallHierarchyTreeItemRefresh(idx: number)
+  var treeItem: dict<any> = w:LspCallHierItemMap[idx]
+
+  if treeItem.open
+    # Already retrieved the children for this item
+    return
+  endif
+
+  if !treeItem->has_key('children')
+    # First time retrieving the children for the item at index "idx"
+    var lspserver = buf.BufLspServerGet(w:LspBufnr, 'callHierarchy')
+    if lspserver->empty() || !lspserver.running
+      return
+    endif
+
+    var reply: any
+    if w:LspCallHierIncoming
+      reply = lspserver.getIncomingCalls(treeItem.item)
+    else
+      reply = lspserver.getOutgoingCalls(treeItem.item)
+    endif
+
+    treeItem.children = []
+    if !reply->empty()
+      for item in reply
+	treeItem.children->add({item: w:LspCallHierIncoming ? item.from :
+				item.to, open: false})
+      endfor
+    endif
+  endif
+
+  # Clear and redisplay the tree in the window
+  treeItem.open = true
+  var save_cursor = getcurpos()
+  CallHierarchyTreeRefresh()
+  setpos('.', save_cursor)
+enddef
+
+# Open the call hierarchy tree item under the cursor
+def CallHierarchyTreeItemOpen()
+  CallHierarchyTreeItemRefresh(line('.'))
+enddef
+
+# Refresh the entire call hierarchy tree
+def CallHierarchyTreeRefreshCmd()
+  w:LspCallHierItemMap[2].open = false
+  w:LspCallHierItemMap[2]->remove('children')
+  CallHierarchyTreeItemRefresh(2)
+enddef
+
+# Display the incoming call hierarchy tree
+def CallHierarchyTreeIncomingCmd()
+  w:LspCallHierItemMap[2].open = false
+  w:LspCallHierItemMap[2]->remove('children')
+  w:LspCallHierIncoming = true
+  CallHierarchyTreeItemRefresh(2)
+enddef
+
+# Display the outgoing call hierarchy tree
+def CallHierarchyTreeOutgoingCmd()
+  w:LspCallHierItemMap[2].open = false
+  w:LspCallHierItemMap[2]->remove('children')
+  w:LspCallHierIncoming = false
+  CallHierarchyTreeItemRefresh(2)
+enddef
+
+# Close the call hierarchy tree item under the cursor
+def CallHierarchyTreeItemClose()
+  var treeItem: dict<any> = w:LspCallHierItemMap[line('.')]
+  treeItem.open = false
+  var save_cursor = getcurpos()
+  CallHierarchyTreeRefresh()
+  setpos('.', save_cursor)
+enddef
+
+# Recursively add the call hierarchy items to w:LspCallHierItemMap
+def CallHierarchyTreeItemShow(incoming: bool, treeItem: dict<any>, pfx: string)
+  var item = treeItem.item
+  var treePfx: string
+  if treeItem.open && treeItem->has_key('children')
+    treePfx = has('gui_running') ? '▼' : '-'
+  else
+    treePfx = has('gui_running') ? '▶' : '+'
+  endif
+  var fname = util.LspUriToFile(item.uri)
+  var s = $'{pfx}{treePfx} {item.name} ({fname->fnamemodify(":t")} [{fname->fnamemodify(":h")}])'
+  append('$', s)
+  w:LspCallHierItemMap->add(treeItem)
+  if treeItem.open && treeItem->has_key('children')
+    for child in treeItem.children
+      CallHierarchyTreeItemShow(incoming, child, $'{pfx}  ')
+    endfor
+  endif
+enddef
+
+def CallHierarchyTreeRefresh()
+  :setlocal modifiable
+  :silent! :%d _
+
+  setline(1, $'# {w:LspCallHierIncoming ? "Incoming calls to" : "Outgoing calls from"} "{w:LspCallHierarchyTree.item.name}"')
+  w:LspCallHierItemMap = [{}, {}]
+  CallHierarchyTreeItemShow(w:LspCallHierIncoming, w:LspCallHierarchyTree, '')
+  :setlocal nomodifiable
+enddef
+
+def CallHierarchyTreeShow(incoming: bool, prepareItem: dict<any>,
+			  items: list<dict<any>>)
+  var save_bufnr = bufnr()
+  var wid = bufwinid('LSP-CallHierarchy')
+  if wid != -1
+    wid->win_gotoid()
+  else
+    :new LSP-CallHierarchy
+    :setlocal buftype=nofile
+    :setlocal bufhidden=wipe
+    :setlocal noswapfile
+    :setlocal nonumber nornu
+    :setlocal fdc=0 signcolumn=no
+
+    :nnoremap <buffer> <CR> <ScriptCmd>CallHierarchyItemJump()<CR>
+    :nnoremap <buffer> - <ScriptCmd>CallHierarchyTreeItemOpen()<CR>
+    :nnoremap <buffer> + <ScriptCmd>CallHierarchyTreeItemClose()<CR>
+    :command -buffer LspCallHierarchyRefresh CallHierarchyTreeRefreshCmd()
+    :command -buffer LspCallHierarchyIncoming CallHierarchyTreeIncomingCmd()
+    :command -buffer LspCallHierarchyOutgoing CallHierarchyTreeOutgoingCmd()
+
+    :syntax match Comment '^#.*$'
+    :syntax match Directory '(.*)$'
+  endif
+
+  w:LspBufnr = save_bufnr
+  w:LspCallHierIncoming = incoming
+  w:LspCallHierarchyTree = {}
+  w:LspCallHierarchyTree.item = prepareItem
+  w:LspCallHierarchyTree.open = true
+  w:LspCallHierarchyTree.children = []
+  for item in items
+    w:LspCallHierarchyTree.children->add({item: incoming ? item.from : item.to, open: false})
+  endfor
+
+  CallHierarchyTreeRefresh()
+
+  :setlocal nomodified
+  :setlocal nomodifiable
+enddef
+
+export def IncomingCalls(lspserver: dict<any>)
+  var prepareReply = lspserver.prepareCallHierarchy()
+  if prepareReply->empty()
+    util.WarnMsg('No incoming calls')
+    return
+  endif
+
+  var reply = lspserver.getIncomingCalls(prepareReply)
+  if reply->empty()
+    util.WarnMsg('No incoming calls')
+    return
+  endif
+
+  CallHierarchyTreeShow(true, prepareReply, reply)
+enddef
+
+export def OutgoingCalls(lspserver: dict<any>)
+  var prepareReply = lspserver.prepareCallHierarchy()
+  if prepareReply->empty()
+    util.WarnMsg('No outgoing calls')
+    return
+  endif
+
+  var reply = lspserver.getOutgoingCalls(prepareReply)
+  if reply->empty()
+    util.WarnMsg('No outgoing calls')
+    return
+  endif
+
+  CallHierarchyTreeShow(false, prepareReply, reply)
+enddef
+
+# vim: tabstop=8 shiftwidth=2 softtabstop=2
diff --git a/vim/pack/downloads/opt/lsp/autoload/lsp/capabilities.vim b/vim/pack/downloads/opt/lsp/autoload/lsp/capabilities.vim
new file mode 100644
index 0000000..46f5973
--- /dev/null
+++ b/vim/pack/downloads/opt/lsp/autoload/lsp/capabilities.vim
@@ -0,0 +1,501 @@
+vim9script
+
+# Functions for managing the LSP server and client capabilities
+
+import './options.vim' as opt
+
+# Process the server capabilities
+#   interface ServerCapabilities
+export def ProcessServerCaps(lspserver: dict<any>, caps: dict<any>)
+  var serverEncoding = 'utf-16'
+  if lspserver.caps->has_key('positionEncoding')
+    serverEncoding = lspserver.caps.positionEncoding
+  elseif lspserver.caps->has_key('~additionalInitResult_offsetEncoding')
+    serverEncoding = lspserver.caps['~additionalInitResult_offsetEncoding']
+  endif
+
+  if lspserver.forceOffsetEncoding != ''
+    serverEncoding = lspserver.forceOffsetEncoding
+  endif
+
+  # one of 'utf-8', 'utf-16' or 'utf-32'
+  if serverEncoding == 'utf-8'
+    lspserver.posEncoding = 8
+  elseif serverEncoding == 'utf-16'
+    lspserver.posEncoding = 16
+  else
+    lspserver.posEncoding = 32
+  endif
+
+  if has('patch-9.0.1629') && lspserver.posEncoding != 32
+    lspserver.needOffsetEncoding = true
+  else
+    lspserver.needOffsetEncoding = false
+  endif
+
+  # completionProvider
+  if lspserver.caps->has_key('completionProvider')
+    lspserver.isCompletionProvider = true
+    if lspserver.caps.completionProvider->has_key('resolveProvider')
+      lspserver.isCompletionResolveProvider =
+			lspserver.caps.completionProvider.resolveProvider
+    else
+      lspserver.isCompletionResolveProvider = false
+    endif
+  else
+    lspserver.isCompletionProvider = false
+    lspserver.isCompletionResolveProvider = false
+  endif
+
+  # definitionProvider
+  if lspserver.caps->has_key('definitionProvider')
+    if lspserver.caps.definitionProvider->type() == v:t_bool
+      lspserver.isDefinitionProvider = lspserver.caps.definitionProvider
+    else
+      lspserver.isDefinitionProvider = true
+    endif
+  else
+    lspserver.isDefinitionProvider = false
+  endif
+
+  # declarationProvider
+  if lspserver.caps->has_key('declarationProvider')
+    if lspserver.caps.declarationProvider->type() == v:t_bool
+      lspserver.isDeclarationProvider = lspserver.caps.declarationProvider
+    else
+      lspserver.isDeclarationProvider = true
+    endif
+  else
+    lspserver.isDeclarationProvider = false
+  endif
+
+  # typeDefinitionProvider
+  if lspserver.caps->has_key('typeDefinitionProvider')
+    if lspserver.caps.typeDefinitionProvider->type() == v:t_bool
+      lspserver.isTypeDefinitionProvider = lspserver.caps.typeDefinitionProvider
+    else
+      lspserver.isTypeDefinitionProvider = true
+    endif
+  else
+    lspserver.isTypeDefinitionProvider = false
+  endif
+
+  # implementationProvider
+  if lspserver.caps->has_key('implementationProvider')
+    if lspserver.caps.implementationProvider->type() == v:t_bool
+      lspserver.isImplementationProvider = lspserver.caps.implementationProvider
+    else
+      lspserver.isImplementationProvider = true
+    endif
+  else
+    lspserver.isImplementationProvider = false
+  endif
+
+  # signatureHelpProvider
+  if lspserver.caps->has_key('signatureHelpProvider')
+    lspserver.isSignatureHelpProvider = true
+  else
+    lspserver.isSignatureHelpProvider = false
+  endif
+
+  # hoverProvider
+  if lspserver.caps->has_key('hoverProvider')
+    if lspserver.caps.hoverProvider->type() == v:t_bool
+      lspserver.isHoverProvider = lspserver.caps.hoverProvider
+    else
+      lspserver.isHoverProvider = true
+    endif
+  else
+    lspserver.isHoverProvider = false
+  endif
+
+  # referencesProvider
+  if lspserver.caps->has_key('referencesProvider')
+    if lspserver.caps.referencesProvider->type() == v:t_bool
+      lspserver.isReferencesProvider = lspserver.caps.referencesProvider
+    else
+      lspserver.isReferencesProvider = true
+    endif
+  else
+    lspserver.isReferencesProvider = false
+  endif
+
+  # documentHighlightProvider
+  if lspserver.caps->has_key('documentHighlightProvider')
+    if lspserver.caps.documentHighlightProvider->type() == v:t_bool
+      lspserver.isDocumentHighlightProvider =
+				lspserver.caps.documentHighlightProvider
+    else
+      lspserver.isDocumentHighlightProvider = true
+    endif
+  else
+    lspserver.isDocumentHighlightProvider = false
+  endif
+
+  # documentSymbolProvider
+  if lspserver.caps->has_key('documentSymbolProvider')
+    if lspserver.caps.documentSymbolProvider->type() == v:t_bool
+      lspserver.isDocumentSymbolProvider =
+				lspserver.caps.documentSymbolProvider
+    else
+      lspserver.isDocumentSymbolProvider = true
+    endif
+  else
+    lspserver.isDocumentSymbolProvider = false
+  endif
+
+  # documentFormattingProvider
+  if lspserver.caps->has_key('documentFormattingProvider')
+    if lspserver.caps.documentFormattingProvider->type() == v:t_bool
+      lspserver.isDocumentFormattingProvider =
+				lspserver.caps.documentFormattingProvider
+    else
+      lspserver.isDocumentFormattingProvider = true
+    endif
+  else
+    lspserver.isDocumentFormattingProvider = false
+  endif
+
+  # callHierarchyProvider
+  if lspserver.caps->has_key('callHierarchyProvider')
+    if lspserver.caps.callHierarchyProvider->type() == v:t_bool
+      lspserver.isCallHierarchyProvider =
+				lspserver.caps.callHierarchyProvider
+    else
+      lspserver.isCallHierarchyProvider = true
+    endif
+  else
+    lspserver.isCallHierarchyProvider = false
+  endif
+
+  # semanticTokensProvider
+  if lspserver.caps->has_key('semanticTokensProvider')
+    lspserver.isSemanticTokensProvider = true
+    lspserver.semanticTokensLegend =
+      lspserver.caps.semanticTokensProvider.legend
+    lspserver.semanticTokensRange =
+      lspserver.caps.semanticTokensProvider->get('range', false)
+    if lspserver.caps.semanticTokensProvider->has_key('full')
+      if lspserver.caps.semanticTokensProvider.full->type() == v:t_bool
+	lspserver.semanticTokensFull =
+	  lspserver.caps.semanticTokensProvider.full
+	lspserver.semanticTokensDelta = false
+      else
+	lspserver.semanticTokensFull = true
+	if lspserver.caps.semanticTokensProvider.full->has_key('delta')
+	  lspserver.semanticTokensDelta =
+	    lspserver.caps.semanticTokensProvider.full.delta
+	else
+	  lspserver.semanticTokensDelta = false
+	endif
+      endif
+    else
+      lspserver.semanticTokensFull = false
+      lspserver.semanticTokensDelta = false
+    endif
+  else
+    lspserver.isSemanticTokensProvider = false
+  endif
+
+  # typeHierarchyProvider
+  if lspserver.caps->has_key('typeHierarchyProvider')
+    lspserver.isTypeHierarchyProvider = true
+  else
+    lspserver.isTypeHierarchyProvider = false
+  endif
+
+  # renameProvider
+  if lspserver.caps->has_key('renameProvider')
+    if lspserver.caps.renameProvider->type() == v:t_bool
+      lspserver.isRenameProvider = lspserver.caps.renameProvider
+    else
+      lspserver.isRenameProvider = true
+    endif
+  else
+    lspserver.isRenameProvider = false
+  endif
+
+  # codeActionProvider
+  if lspserver.caps->has_key('codeActionProvider')
+    if lspserver.caps.codeActionProvider->type() == v:t_bool
+      lspserver.isCodeActionProvider = lspserver.caps.codeActionProvider
+    else
+      lspserver.isCodeActionProvider = true
+    endif
+  else
+    lspserver.isCodeActionProvider = false
+  endif
+
+  # codeLensProvider
+  if lspserver.caps->has_key('codeLensProvider')
+    lspserver.isCodeLensProvider = true
+    if lspserver.caps.codeLensProvider->has_key('resolveProvider')
+      lspserver.isCodeLensResolveProvider = true
+    else
+      lspserver.isCodeLensResolveProvider = false
+    endif
+  else
+    lspserver.isCodeLensProvider = false
+  endif
+
+  # workspaceSymbolProvider
+  if lspserver.caps->has_key('workspaceSymbolProvider')
+    if lspserver.caps.workspaceSymbolProvider->type() == v:t_bool
+      lspserver.isWorkspaceSymbolProvider =
+				lspserver.caps.workspaceSymbolProvider
+    else
+      lspserver.isWorkspaceSymbolProvider = true
+    endif
+  else
+    lspserver.isWorkspaceSymbolProvider = false
+  endif
+
+  # selectionRangeProvider
+  if lspserver.caps->has_key('selectionRangeProvider')
+    if lspserver.caps.selectionRangeProvider->type() == v:t_bool
+      lspserver.isSelectionRangeProvider =
+				lspserver.caps.selectionRangeProvider
+    else
+      lspserver.isSelectionRangeProvider = true
+    endif
+  else
+    lspserver.isSelectionRangeProvider = false
+  endif
+
+  # foldingRangeProvider
+  if lspserver.caps->has_key('foldingRangeProvider')
+    if lspserver.caps.foldingRangeProvider->type() == v:t_bool
+      lspserver.isFoldingRangeProvider = lspserver.caps.foldingRangeProvider
+    else
+      lspserver.isFoldingRangeProvider = true
+    endif
+  else
+    lspserver.isFoldingRangeProvider = false
+  endif
+
+  # inlayHintProvider
+  if lspserver.caps->has_key('inlayHintProvider')
+    if lspserver.caps.inlayHintProvider->type() == v:t_bool
+      lspserver.isInlayHintProvider = lspserver.caps.inlayHintProvider
+    else
+      lspserver.isInlayHintProvider = true
+    endif
+  else
+    lspserver.isInlayHintProvider = false
+  endif
+
+  # clangdInlayHintsProvider
+  if lspserver.caps->has_key('clangdInlayHintsProvider')
+    lspserver.isClangdInlayHintsProvider =
+					lspserver.caps.clangdInlayHintsProvider
+  else
+    lspserver.isClangdInlayHintsProvider = false
+  endif
+
+  # textDocumentSync capabilities
+  lspserver.supportsDidSave = false
+  # Default to TextDocumentSyncKind.None
+  lspserver.textDocumentSync = 0
+  if lspserver.caps->has_key('textDocumentSync')
+    if lspserver.caps.textDocumentSync->type() == v:t_bool
+	|| lspserver.caps.textDocumentSync->type() == v:t_number
+      lspserver.supportsDidSave = lspserver.caps.textDocumentSync
+      lspserver.textDocumentSync = lspserver.caps.textDocumentSync
+    elseif lspserver.caps.textDocumentSync->type() == v:t_dict
+      # "save"
+      if lspserver.caps.textDocumentSync->has_key('save')
+	if lspserver.caps.textDocumentSync.save->type() == v:t_bool
+	    || lspserver.caps.textDocumentSync.save->type() == v:t_number
+	  lspserver.supportsDidSave = lspserver.caps.textDocumentSync.save
+	elseif lspserver.caps.textDocumentSync.save->type() == v:t_dict
+	  lspserver.supportsDidSave = true
+	endif
+      endif
+      # "change"
+      if lspserver.caps.textDocumentSync->has_key('change')
+	lspserver.textDocumentSync = lspserver.caps.textDocumentSync.change
+      endif
+    endif
+  endif
+enddef
+
+# Return all the LSP client capabilities
+export def GetClientCaps(): dict<any>
+  # client capabilities (ClientCapabilities)
+  var clientCaps: dict<any> = {
+    general: {
+      # Currently we always send character count as position offset,
+      # which meanas only utf-32 is supported.
+      # Adding utf-16 simply for good mesure, as I'm scared some servers will
+      # give up if they don't support utf-32 only.
+      positionEncodings: ['utf-32', 'utf-16']
+    },
+    textDocument: {
+      callHierarchy: {
+	dynamicRegistration: false
+      },
+      codeAction: {
+	dynamicRegistration: false,
+	codeActionLiteralSupport: {
+	  codeActionKind: {
+	    valueSet: ['', 'quickfix', 'refactor', 'refactor.extract',
+			'refactor.inline', 'refactor.rewrite', 'source',
+			'source.organizeImports']
+	  }
+	},
+	isPreferredSupport: true,
+	disabledSupport: true
+      },
+      codeLens: {
+	dynamicRegistration: false
+      },
+      completion: {
+	dynamicRegistration: false,
+	completionItem: {
+	  documentationFormat: ['markdown', 'plaintext'],
+	  resolveSupport: {
+	    properties: ['detail', 'documentation']
+	  },
+	  snippetSupport: opt.lspOptions.snippetSupport,
+	  insertReplaceSupport: false
+	},
+	completionItemKind: {
+	  valueSet: range(1, 25)
+	}
+      },
+      declaration: {
+	dynamicRegistration: false,
+	linkSupport: true
+      },
+      definition: {
+	dynamicRegistration: false,
+	linkSupport: true
+      },
+      documentHighlight: {
+	dynamicRegistration: false
+      },
+      documentSymbol: {
+	dynamicRegistration: false,
+	symbolKind: {
+	  valueSet: range(1, 25)
+	},
+	hierarchicalDocumentSymbolSupport: true,
+	labelSupport: false
+      },
+      foldingRange: {
+	dynamicRegistration: false,
+	rangeLimit: 5000,
+	lineFoldingOnly: true,
+	foldingRangeKind: {
+	  valueSet: ['comment', 'imports', 'region']
+	},
+	foldingRange: {
+	  collapsedText: true
+	}
+      },
+      formatting: {
+	dynamicRegistration: false
+      },
+      hover: {
+	dynamicRegistration: false,
+	contentFormat: ['markdown', 'plaintext']
+      },
+      implementation: {
+	dynamicRegistration: false,
+	linkSupport: true
+      },
+      inlayHint: {
+	dynamicRegistration: false
+      },
+      publishDiagnostics: {
+	relatedInformation: false,
+	versionSupport: true,
+	codeDescriptionSupport: true,
+	dataSupport: true
+      },
+      rangeFormatting: {
+	dynamicRegistration: false
+      },
+      references: {
+	dynamicRegistration: false
+      },
+      rename: {
+	dynamicRegistration: false,
+	prepareSupport: false,
+      },
+      selectionRange: {
+	dynamicRegistration: false,
+      },
+      signatureHelp: {
+	dynamicRegistration: false,
+	signatureInformation: {
+	  documentationFormat: ['markdown', 'plaintext'],
+	  activeParameterSupport: true
+	}
+      },
+      semanticTokens: {
+	dynamicRegistration: false,
+	requests: {
+	  range: false,
+	  full: {
+	    delta: true
+	  }
+	},
+	tokenTypes: [
+	  'type', 'class', 'enum', 'interface', 'struct', 'typeParameter',
+	  'parameter', 'variable', 'property', 'enumMember', 'event',
+	  'function', 'method', 'macro', 'keyword', 'modifier', 'comment',
+	  'string', 'number', 'regexp', 'operator'
+	],
+	tokenModifiers: [
+	  'declaration', 'definition', 'readonly', 'static', 'deprecated',
+	  'abstract', 'async', 'modification', 'documentation',
+	  'defaultLibrary'
+	],
+	formats: ['relative'],
+	overlappingTokenSupport: false,
+	multilineTokenSupport: false,
+	serverCancelSupport: false,
+	augmentsSyntaxTokens: true
+      },
+      synchronization: {
+	dynamicRegistration: false,
+	didSave: true,
+	willSave: false,
+	WillSaveWaitUntil: false
+      },
+      typeDefinition: {
+	dynamicRegistration: false,
+	linkSupport: true
+      },
+      typeHierarchy: {
+	dynamicRegistration: false,
+      }
+    },
+    window: {},
+    workspace: {
+      workspaceFolders: true,
+      applyEdit: true,
+      workspaceEdit: {
+	resourceOperations: ['rename', 'create', 'delete']
+      },
+      configuration: true,
+      symbol: {
+	dynamicRegistration: false
+      }
+    },
+    # This is the way clangd expects to be informated about supported encodings:
+    # https://clangd.llvm.org/extensions#utf-8-offsets
+    offsetEncoding: ['utf-32', 'utf-16']
+  }
+
+  # Vim patch 1629 is needed to properly encode/decode UTF-16 offsets
+  if has('patch-9.0.1629')
+    clientCaps.general.positionEncodings = ['utf-32', 'utf-16', 'utf-8']
+    clientCaps.offsetEncoding = ['utf-32', 'utf-16', 'utf-8']
+  endif
+
+  return clientCaps
+enddef
+
+# vim: tabstop=8 shiftwidth=2 softtabstop=2
diff --git a/vim/pack/downloads/opt/lsp/autoload/lsp/codeaction.vim b/vim/pack/downloads/opt/lsp/autoload/lsp/codeaction.vim
new file mode 100644
index 0000000..fb2a91a
--- /dev/null
+++ b/vim/pack/downloads/opt/lsp/autoload/lsp/codeaction.vim
@@ -0,0 +1,135 @@
+vim9script
+
+# Functions related to handling LSP code actions to fix diagnostics.
+
+import './util.vim'
+import './textedit.vim'
+import './options.vim' as opt
+
+var CommandHandlers: dict<func>
+
+export def RegisterCmdHandler(cmd: string, Handler: func)
+  CommandHandlers[cmd] = Handler
+enddef
+
+export def DoCommand(lspserver: dict<any>, cmd: dict<any>)
+  if cmd->has_key('command') && CommandHandlers->has_key(cmd.command)
+    var CmdHandler: func = CommandHandlers[cmd.command]
+    try
+      call CmdHandler(cmd)
+    catch
+      util.ErrMsg($'"{cmd.command}" handler raised exception {v:exception}')
+    endtry
+  else
+    lspserver.executeCommand(cmd)
+  endif
+enddef
+
+# Apply the code action selected by the user.
+export def HandleCodeAction(lspserver: dict<any>, selAction: dict<any>)
+  # textDocument/codeAction can return either Command[] or CodeAction[].
+  # If it is a CodeAction, it can have either an edit, a command or both.
+  # Edits should be executed first.
+  # Both Command and CodeAction interfaces has "command" member
+  # so we should check "command" type - for Command it will be "string"
+  if selAction->has_key('edit')
+     || (selAction->has_key('command') && selAction.command->type() == v:t_dict)
+    # selAction is a CodeAction instance, apply edit and command
+    if selAction->has_key('edit')
+      # apply edit first
+      textedit.ApplyWorkspaceEdit(selAction.edit)
+    endif
+    if selAction->has_key('command')
+      DoCommand(lspserver, selAction.command)
+    endif
+  else
+    # selAction is a Command instance, apply it directly
+    DoCommand(lspserver, selAction)
+  endif
+enddef
+
+# Process the list of code actions returned by the LSP server, ask the user to
+# choose one action from the list and then apply it.
+# If "query" is a number, then apply the corresponding action in the list.
+# If "query" is a regular expression starting with "/", then apply the action
+# matching the search string in the list.
+# If "query" is a regular string, then apply the action matching the string.
+# If "query" is an empty string, then if the "usePopupInCodeAction" option is
+# configured by the user, then display the list of items in a popup menu.
+# Otherwise display the items in an input list and prompt the user to select
+# an action.
+export def ApplyCodeAction(lspserver: dict<any>, actionlist: list<dict<any>>, query: string): void
+  var actions = actionlist
+
+  if opt.lspOptions.hideDisabledCodeActions
+    actions = actions->filter((ix, act) => !act->has_key('disabled'))
+  endif
+
+  if actions->empty()
+    # no action can be performed
+    util.WarnMsg('No code action is available')
+    return
+  endif
+
+  var text: list<string> = []
+  var act: dict<any>
+  for i in actions->len()->range()
+    act = actions[i]
+    var t: string = act.title->substitute('\r\n', '\\r\\n', 'g')
+    t = t->substitute('\n', '\\n', 'g')
+    text->add(printf(" %d. %s ", i + 1, t))
+  endfor
+
+  var choice: number
+
+  var query_ = query->trim()
+  if query_ =~ '^\d\+$'	# digit
+    choice = query_->str2nr()
+  elseif query_ =~ '^/'	# regex
+    choice = 1 + util.Indexof(actions, (i, a) => a.title =~ query_[1 : ])
+  elseif query_ != ''	# literal string
+    choice = 1 + util.Indexof(actions, (i, a) => a.title[0 : query_->len() - 1] == query_)
+  elseif opt.lspOptions.usePopupInCodeAction
+    # Use a popup menu to show the code action
+    popup_create(text, {
+      pos: 'botleft',
+      line: 'cursor-1',
+      col: 'cursor',
+      zindex: 1000,
+      cursorline: 1,
+      mapping: 0,
+      wrap: 0,
+      title: 'Code action',
+      callback: (_, result) => {
+	# Invalid item selected or closed the popup
+	if result <= 0 || result > text->len()
+	  return
+	endif
+
+	# Do the code action
+	HandleCodeAction(lspserver, actions[result - 1])
+      },
+      filter: (winid, key) => {
+	if key == 'h' || key == 'l'
+	  winid->popup_close(-1)
+	elseif key->str2nr() > 0
+	  # assume less than 10 entries are present
+	  winid->popup_close(key->str2nr())
+	else
+	  return popup_filter_menu(winid, key)
+	endif
+	return 1
+      },
+    })
+  else
+    choice = inputlist(['Code action:'] + text)
+  endif
+
+  if choice < 1 || choice > text->len()
+    return
+  endif
+
+  HandleCodeAction(lspserver, actions[choice - 1])
+enddef
+
+# vim: tabstop=8 shiftwidth=2 softtabstop=2
diff --git a/vim/pack/downloads/opt/lsp/autoload/lsp/codelens.vim b/vim/pack/downloads/opt/lsp/autoload/lsp/codelens.vim
new file mode 100644
index 0000000..082edf7
--- /dev/null
+++ b/vim/pack/downloads/opt/lsp/autoload/lsp/codelens.vim
@@ -0,0 +1,32 @@
+vim9script
+
+import './codeaction.vim'
+
+# Functions related to handling LSP code lens
+
+export def ProcessCodeLens(lspserver: dict<any>, bnr: number, codeLensItems: list<dict<any>>)
+  var text: list<string> = []
+  for i in codeLensItems->len()->range()
+    var item = codeLensItems[i]
+    if !item->has_key('command')
+      # resolve the code lens
+      item = lspserver.resolveCodeLens(bnr, item)
+      if item->empty()
+	continue
+      endif
+      codeLensItems[i] = item
+    endif
+    text->add(printf("%d. %s\t| L%s:%s", i + 1, item.command.title,
+			item.range.start.line + 1,
+			getline(item.range.start.line + 1)))
+  endfor
+
+  var choice = inputlist(['Code Lens:'] + text)
+  if choice < 1 || choice > codeLensItems->len()
+    return
+  endif
+
+  codeaction.DoCommand(lspserver, codeLensItems[choice - 1].command)
+enddef
+
+# vim: tabstop=8 shiftwidth=2 softtabstop=2
diff --git a/vim/pack/downloads/opt/lsp/autoload/lsp/completion.vim b/vim/pack/downloads/opt/lsp/autoload/lsp/completion.vim
new file mode 100644
index 0000000..8ce5899
--- /dev/null
+++ b/vim/pack/downloads/opt/lsp/autoload/lsp/completion.vim
@@ -0,0 +1,708 @@
+vim9script
+
+# LSP completion related functions
+
+import './util.vim'
+import './buffer.vim' as buf
+import './options.vim' as opt
+import './textedit.vim'
+import './snippet.vim'
+import './codeaction.vim'
+
+# per-filetype omni-completion enabled/disabled table
+var ftypeOmniCtrlMap: dict<bool> = {}
+
+var defaultKinds: dict<string> = {
+  'Text':           't',
+  'Method':         'm',
+  'Function':       'f',
+  'Constructor':    'C',
+  'Field':          'F',
+  'Variable':       'v',
+  'Class':          'c',
+  'Interface':      'i',
+  'Module':         'M',
+  'Property':       'p',
+  'Unit':           'u',
+  'Value':          'V',
+  'Enum':           'e',
+  'Keyword':        'k',
+  'Snippet':        'S',
+  'Color':          'C',
+  'File':           'f',
+  'Reference':      'r',
+  'Folder':         'F',
+  'EnumMember':     'E',
+  'Constant':       'd',
+  'Struct':         's',
+  'Event':          'E',
+  'Operator':       'o',
+  'TypeParameter':  'T',
+  'Buffer':         'B',
+}
+
+# Returns true if omni-completion is enabled for filetype "ftype".
+# Otherwise, returns false.
+def LspOmniComplEnabled(ftype: string): bool
+  return ftypeOmniCtrlMap->get(ftype, false)
+enddef
+
+# Enables or disables omni-completion for filetype "fype"
+export def OmniComplSet(ftype: string, enabled: bool)
+  ftypeOmniCtrlMap->extend({[ftype]: enabled})
+enddef
+
+# Map LSP complete item kind to a character
+def LspCompleteItemKindChar(kind: number): string
+  var kindMap: list<string> = [
+    '',
+    'Text',
+    'Method',
+    'Function',
+    'Constructor',
+    'Field',
+    'Variable',
+    'Class',
+    'Interface',
+    'Module',
+    'Property',
+    'Unit',
+    'Value',
+    'Enum',
+    'Keyword',
+    'Snippet',
+    'Color',
+    'File',
+    'Reference',
+    'Folder',
+    'EnumMember',
+    'Constant',
+    'Struct',
+    'Event',
+    'Operator',
+    'TypeParameter',
+    'Buffer'
+  ]
+
+  if kind > 26
+    return ''
+  endif
+
+  var kindName = kindMap[kind]
+  var kindValue = defaultKinds[kindName]
+
+  var lspOpts = opt.lspOptions
+  if lspOpts.customCompletionKinds &&
+      lspOpts.completionKinds->has_key(kindName)
+    kindValue = lspOpts.completionKinds[kindName]
+  endif
+
+  return kindValue
+enddef
+
+# Remove all the snippet placeholders from "str" and return the value.
+# Based on a similar function in the vim-lsp plugin.
+def MakeValidWord(str_arg: string): string
+  var str = str_arg->substitute('\$[0-9]\+\|\${\%(\\.\|[^}]\)\+}', '', 'g')
+  str = str->substitute('\\\(.\)', '\1', 'g')
+  var valid = str->matchstr('^[^"'' (<{\[\t\r\n]\+')
+  if valid->empty()
+    return str
+  endif
+  if valid =~ ':$'
+    return valid[: -2]
+  endif
+  return valid
+enddef
+
+# add completion from current buf
+def CompletionFromBuffer(items: list<dict<any>>)
+  var words = {}
+  var start = reltime()
+  var timeout = opt.lspOptions.bufferCompletionTimeout
+  var linenr = 1
+  for line in getline(1, '$')
+    for word in line->split('\W\+')
+      if !words->has_key(word) && word->len() > 1
+	words[word] = 1
+	items->add({
+	  label: word,
+	  data: {
+	    entryNames: [word],
+	  },
+	  kind: 26,
+	  documentation: "",
+	})
+      endif
+    endfor
+    # Check every 200 lines if timeout is exceeded
+    if timeout > 0 && linenr % 200 == 0 &&
+	start->reltime()->reltimefloat() * 1000 > timeout
+      break
+    endif
+    linenr += 1
+  endfor
+enddef
+
+# process the 'textDocument/completion' reply from the LSP server
+# Result: CompletionItem[] | CompletionList | null
+export def CompletionReply(lspserver: dict<any>, cItems: any)
+  lspserver.completeItemsIsIncomplete = false
+  if cItems->empty()
+    if lspserver.omniCompletePending
+      lspserver.completeItems = []
+      lspserver.omniCompletePending = false
+    endif
+    return
+  endif
+
+  var items: list<dict<any>>
+  if cItems->type() == v:t_list
+    items = cItems
+  else
+    items = cItems.items
+    lspserver.completeItemsIsIncomplete = cItems->get('isIncomplete', false)
+  endif
+
+  var lspOpts = opt.lspOptions
+
+  # Get the keyword prefix before the current cursor column.
+  var chcol = charcol('.')
+  var starttext = chcol == 1 ? '' : getline('.')[ : chcol - 2]
+  var [prefix, start_idx, end_idx] = starttext->matchstrpos('\k*$')
+  if lspOpts.completionMatcherValue == opt.COMPLETIONMATCHER_ICASE
+    prefix = prefix->tolower()
+  endif
+
+  var start_col = start_idx + 1
+
+  if lspOpts.ultisnipsSupport
+    snippet.CompletionUltiSnips(prefix, items)
+  elseif lspOpts.vsnipSupport
+    snippet.CompletionVsnip(items)
+  endif
+
+  if lspOpts.useBufferCompletion
+    CompletionFromBuffer(items)
+  endif
+
+  var completeItems: list<dict<any>> = []
+  var itemsUsed: list<string> = []
+  for item in items
+    var d: dict<any> = {}
+
+    # TODO: Add proper support for item.textEdit.newText and
+    # item.textEdit.range.  Keep in mind that item.textEdit.range can start
+    # way before the typed keyword.
+    if item->has_key('textEdit') &&
+	lspOpts.completionMatcherValue != opt.COMPLETIONMATCHER_FUZZY
+      var start_charcol: number
+      if !prefix->empty()
+	start_charcol = charidx(starttext, start_idx) + 1
+      else
+	start_charcol = chcol
+      endif
+      var textEdit = item.textEdit
+      var textEditRange: dict<any> = {}
+      if textEdit->has_key('range')
+	textEditRange = textEdit.range
+      elseif textEdit->has_key('insert')
+	textEditRange = textEdit.insert
+      endif
+      var textEditStartCol =
+		util.GetCharIdxWithoutCompChar(bufnr(), textEditRange.start)
+      if textEditStartCol != start_charcol
+	var offset = start_charcol - textEditStartCol - 1
+	d.word = textEdit.newText[offset : ]
+      else
+	d.word = textEdit.newText
+      endif
+    elseif item->has_key('insertText')
+      d.word = item.insertText
+    else
+      d.word = item.label
+    endif
+
+    if item->get('insertTextFormat', 1) == 2
+      # snippet completion.  Needs a snippet plugin to expand the snippet.
+      # Remove all the snippet placeholders
+      d.word = MakeValidWord(d.word)
+    elseif !lspserver.completeItemsIsIncomplete || lspOpts.useBufferCompletion
+      # Filter items only when "isIncomplete" is set (otherwise server would
+      #   have done the filtering) or when buffer completion is enabled
+
+      # plain text completion
+      if !prefix->empty()
+	# If the completion item text doesn't start with the current (case
+	# ignored) keyword prefix, skip it.
+	var filterText: string = item->get('filterText', d.word)
+	if lspOpts.completionMatcherValue == opt.COMPLETIONMATCHER_ICASE
+	  if filterText->tolower()->stridx(prefix) != 0
+	    continue
+	  endif
+	# If the completion item text doesn't fuzzy match with the current
+	# keyword prefix, skip it.
+	elseif lspOpts.completionMatcherValue == opt.COMPLETIONMATCHER_FUZZY
+	  if matchfuzzy([filterText], prefix)->empty()
+	    continue
+	  endif
+	# If the completion item text doesn't start with the current keyword
+	# prefix, skip it.
+	else
+	  if filterText->stridx(prefix) != 0
+	    continue
+	  endif
+	endif
+      endif
+    endif
+
+    d.abbr = item.label
+    d.dup = 1
+
+    if lspOpts.completionMatcherValue == opt.COMPLETIONMATCHER_ICASE
+      d.icase = 1
+    endif
+
+    if item->has_key('kind') && item.kind != null
+      # namespace CompletionItemKind
+      # map LSP kind to complete-item-kind
+      d.kind = LspCompleteItemKindChar(item.kind)
+    endif
+
+    if lspserver.completionLazyDoc
+      d.info = 'Lazy doc'
+    else
+      if item->has_key('detail') && !item.detail->empty()
+	# Solve a issue where if a server send a detail field
+	# with a "\n", on the menu will be everything joined with
+	# a "^@" separating it. (example: clangd)
+	d.menu = item.detail->split("\n")[0]
+      endif
+      if item->has_key('documentation')
+	var itemDoc = item.documentation
+	if itemDoc->type() == v:t_string && !itemDoc->empty()
+	  d.info = itemDoc
+	elseif itemDoc->type() == v:t_dict
+	    && itemDoc.value->type() == v:t_string
+	  d.info = itemDoc.value
+	endif
+      endif
+    endif
+
+    # Score is used for sorting.
+    d.score = item->get('sortText')
+    if d.score->empty()
+      d.score = item->get('label', '')
+    endif
+
+    # Dont include duplicate items
+    if lspOpts.filterCompletionDuplicates       
+      var key = d->get('word', '') ..
+                d->get('info', '') ..
+                d->get('kind', '') ..
+                d->get('score', '') ..
+                d->get('abbr', '') ..
+                d->get('dup', '')
+      if index(itemsUsed, key) != -1            
+        continue                                                                          
+      endif                                                                      
+      add(itemsUsed, key)                       
+    endif  
+
+    d.user_data = item
+    completeItems->add(d)
+  endfor
+
+  if lspOpts.completionMatcherValue != opt.COMPLETIONMATCHER_FUZZY
+    # Lexographical sort (case-insensitive).
+    completeItems->sort((a, b) =>
+      a.score == b.score ? 0 : a.score >? b.score ? 1 : -1)
+  endif
+
+  if lspOpts.autoComplete && !lspserver.omniCompletePending
+    if completeItems->empty()
+      # no matches
+      return
+    endif
+
+    var m = mode()
+    if m != 'i' && m != 'R' && m != 'Rv'
+      # If not in insert or replace mode, then don't start the completion
+      return
+    endif
+
+    if completeItems->len() == 1
+	&& getline('.')->matchstr($'\C{completeItems[0].word}\>') != ''
+      # only one complete match. No need to show the completion popup
+      return
+    endif
+
+    completeItems->complete(start_col)
+  else
+    lspserver.completeItems = completeItems
+    lspserver.omniCompletePending = false
+  endif
+enddef
+
+# Check if completion item is selected
+def CheckCompletionItemSel(label: string): bool
+  var cInfo = complete_info()
+  if cInfo->empty() || !cInfo.pum_visible || cInfo.selected == -1
+    return false
+  endif
+  var selItem = cInfo.items->get(cInfo.selected, {})
+  if selItem->empty()
+      || selItem->type() != v:t_dict
+      || selItem.user_data->type() != v:t_dict
+      || selItem.user_data.label != label
+    return false
+  endif
+  return true
+enddef
+
+# Process the completion documentation
+def ShowCompletionDocumentation(cItem: any)
+  if cItem->empty() || cItem->type() != v:t_dict
+    return
+  endif
+
+  # check if completion item is still selected
+  if !CheckCompletionItemSel(cItem.label)
+    return
+  endif
+
+  var infoText: list<string>
+  var infoKind: string
+
+  if cItem->has_key('detail') && !cItem.detail->empty()
+    # Solve a issue where if a server send the detail field with "\n",
+    # on the completion popup, everything will be joined with "^@"
+    # (example: typescript-language-server)
+    infoText->extend(cItem.detail->split("\n"))
+  endif
+
+  if cItem->has_key('documentation')
+    if !infoText->empty()
+      infoText->extend(['- - -'])
+    endif
+    var cItemDoc = cItem.documentation
+    if cItemDoc->type() == v:t_dict
+      # MarkupContent
+      if cItemDoc.kind == 'plaintext'
+	infoText->extend(cItemDoc.value->split("\n"))
+	infoKind = 'text'
+      elseif cItemDoc.kind == 'markdown'
+	infoText->extend(cItemDoc.value->split("\n"))
+	infoKind = 'lspgfm'
+      else
+	util.ErrMsg($'Unsupported documentation type ({cItemDoc.kind})')
+	return
+      endif
+    elseif cItemDoc->type() == v:t_string
+      infoText->extend(cItemDoc->split("\n"))
+    else
+      util.ErrMsg($'Unsupported documentation ({cItemDoc->string()})')
+      return
+    endif
+  endif
+
+  if infoText->empty()
+    return
+  endif
+
+  # check if completion item is changed in meantime
+  if !CheckCompletionItemSel(cItem.label)
+    return
+  endif
+
+  # autoComplete or &omnifunc with &completeopt =~ 'popup'
+  var id = popup_findinfo()
+  if id > 0
+    var bufnr = id->winbufnr()
+    id->popup_settext(infoText)
+    infoKind->setbufvar(bufnr, '&ft')
+    id->popup_show()
+  else
+    # &omnifunc with &completeopt =~ 'preview'
+    try
+      :wincmd P
+      :setlocal modifiable
+      bufnr()->deletebufline(1, '$')
+      infoText->append(0)
+      [1, 1]->cursor()
+      exe $'setlocal ft={infoKind}'
+      :wincmd p
+    catch /E441/ # No preview window
+    endtry
+  endif
+enddef
+
+# process the 'completionItem/resolve' reply from the LSP server
+# Result: CompletionItem
+export def CompletionResolveReply(lspserver: dict<any>, cItem: any)
+  ShowCompletionDocumentation(cItem)
+enddef
+
+# Return trigger kind and trigger char. If completion trigger is not a keyword
+# and not one of the triggerCharacters, return -1 for triggerKind.
+def GetTriggerAttributes(lspserver: dict<any>): list<any>
+  var triggerKind: number = 1
+  var triggerChar: string = ''
+
+  # Trigger kind is 1 for keyword and 2 for trigger char initiated completion.
+  var line: string = getline('.')
+  var cur_col = charcol('.')
+  if line[cur_col - 2] !~ '\k'
+    var trigChars = lspserver.completionTriggerChars
+    var trigidx = trigChars->index(line[cur_col - 2])
+    if trigidx == -1
+      triggerKind = -1
+    else
+      triggerKind = 2
+      triggerChar = trigChars[trigidx]
+    endif
+  endif
+  return [triggerKind, triggerChar]
+enddef
+
+
+# omni complete handler
+def g:LspOmniFunc(findstart: number, base: string): any
+  var lspserver: dict<any> = buf.CurbufGetServerChecked('completion')
+  if lspserver->empty()
+    return -2
+  endif
+
+  if findstart
+
+    var [triggerKind, triggerChar] = GetTriggerAttributes(lspserver)
+    if triggerKind < 0
+      # previous character is not a keyword character or a trigger character,
+      # so cancel omni completion.
+      return -2
+    endif
+
+    # first send all the changes in the current buffer to the LSP server
+    listener_flush()
+
+    lspserver.omniCompletePending = true
+    lspserver.completeItems = []
+
+    # initiate a request to LSP server to get list of completions
+    lspserver.getCompletion(triggerKind, triggerChar)
+
+    # locate the start of the word
+    var line = getline('.')->strpart(0, col('.') - 1)
+    var keyword = line->matchstr('\k\+$')
+    lspserver.omniCompleteKeyword = keyword
+    return line->len() - keyword->len()
+  else
+    # Wait for the list of matches from the LSP server
+    var count: number = 0
+    while lspserver.omniCompletePending && count < 1000
+      if complete_check()
+	return v:none
+      endif
+      sleep 2m
+      count += 1
+    endwhile
+
+    if lspserver.omniCompletePending
+      return v:none
+    endif
+
+    var res: list<dict<any>> = lspserver.completeItems
+    var prefix = lspserver.omniCompleteKeyword
+
+    # Don't attempt to filter on the items, when "isIncomplete" is set
+    if prefix->empty() || lspserver.completeItemsIsIncomplete
+      return res
+    endif
+
+    var lspOpts = opt.lspOptions
+    if lspOpts.completionMatcherValue == opt.COMPLETIONMATCHER_FUZZY
+      return res->matchfuzzy(prefix, { key: 'word' })
+    endif
+
+    if lspOpts.completionMatcherValue == opt.COMPLETIONMATCHER_ICASE
+      return res->filter((i, v) =>
+	v.word->tolower()->stridx(prefix->tolower()) == 0)
+    endif
+
+    return res->filter((i, v) => v.word->stridx(prefix) == 0)
+  endif
+enddef
+
+# For plugins that implement async completion this function indicates if
+# omnifunc is waiting for LSP response.
+def g:LspOmniCompletePending(): bool
+  var lspserver: dict<any> = buf.CurbufGetServerChecked('completion')
+  return !lspserver->empty() && lspserver.omniCompletePending
+enddef
+
+# Insert mode completion handler. Used when 24x7 completion is enabled
+# (default).
+def LspComplete()
+  var lspserver: dict<any> = buf.CurbufGetServer('completion')
+  if lspserver->empty() || !lspserver.running || !lspserver.ready
+    return
+  endif
+
+  var [triggerKind, triggerChar] = GetTriggerAttributes(lspserver)
+  if triggerKind < 0
+    return
+  endif
+
+  # first send all the changes in the current buffer to the LSP server
+  listener_flush()
+
+  # initiate a request to LSP server to get list of completions
+  lspserver.getCompletion(triggerKind, triggerChar)
+enddef
+
+# Lazy complete documentation handler
+def LspResolve()
+  var lspserver: dict<any> = buf.CurbufGetServerChecked('completion')
+  if lspserver->empty()
+    return
+  endif
+
+  var item = v:event.completed_item
+  if item->has_key('user_data') && !item.user_data->empty()
+      if item.user_data->type() == v:t_dict && !item.user_data->has_key('documentation')
+	lspserver.resolveCompletion(item.user_data)
+      else
+	ShowCompletionDocumentation(item.user_data)
+      endif
+  endif
+enddef
+
+# If the completion popup documentation window displays "markdown" content,
+# then set the 'filetype' to "lspgfm".
+def LspSetPopupFileType()
+  var item = v:event.completed_item
+  var cItem = item->get('user_data', {})
+  if cItem->empty()
+    return
+  endif
+
+  if cItem->type() != v:t_dict || !cItem->has_key('documentation')
+	\ || cItem.documentation->type() != v:t_dict
+	\ || cItem.documentation.kind != 'markdown'
+    return
+  endif
+
+  var id = popup_findinfo()
+  if id > 0
+    var bnum = id->winbufnr()
+    setbufvar(bnum, '&ft', 'lspgfm')
+  endif
+enddef
+
+# complete done handler (LSP server-initiated actions after completion)
+def LspCompleteDone(bnr: number)
+  var lspserver: dict<any> = buf.BufLspServerGet(bnr, 'completion')
+  if lspserver->empty()
+    return
+  endif
+
+  if v:completed_item->type() != v:t_dict
+    return
+  endif
+
+  var completionData: any = v:completed_item->get('user_data', '')
+  if completionData->type() != v:t_dict
+      || !opt.lspOptions.completionTextEdit
+    return
+  endif
+
+  if !completionData->has_key('additionalTextEdits')
+    # Some language servers (e.g. typescript) delay the computation of the
+    # additional text edits.  So try to resolve the completion item now to get
+    # the text edits.
+    completionData = lspserver.resolveCompletion(completionData, true)
+  endif
+  if !completionData->get('additionalTextEdits', {})->empty()
+    textedit.ApplyTextEdits(bnr, completionData.additionalTextEdits)
+  endif
+
+  if completionData->has_key('command')
+    # Some language servers (e.g. haskell-language-server) want to apply
+    # additional commands after completion.
+    codeaction.DoCommand(lspserver, completionData.command)
+  endif
+
+enddef
+
+# Initialize buffer-local completion options and autocmds
+export def BufferInit(lspserver: dict<any>, bnr: number, ftype: string)
+  if !lspserver.isCompletionProvider
+    # no support for completion
+    return
+  endif
+
+  if !opt.lspOptions.autoComplete && !LspOmniComplEnabled(ftype) && !opt.lspOptions.omniComplete
+    # LSP auto/omni completion support is not enabled for this buffer
+    return
+  endif
+
+  # buffer-local autocmds for completion
+  var acmds: list<dict<any>> = []
+
+  # set options for insert mode completion
+  if opt.lspOptions.autoComplete
+    if lspserver.completionLazyDoc
+      setbufvar(bnr, '&completeopt', 'menuone,popuphidden,noinsert,noselect')
+    else
+      setbufvar(bnr, '&completeopt', 'menuone,popup,noinsert,noselect')
+    endif
+    setbufvar(bnr, '&completepopup',
+	      'width:80,highlight:Pmenu,align:item,border:off')
+    # <Enter> in insert mode stops completion and inserts a <Enter>
+    if !opt.lspOptions.noNewlineInCompletion
+      :inoremap <expr> <buffer> <CR> pumvisible() ? "\<C-Y>\<CR>" : "\<CR>"
+    endif
+
+    # Trigger 24x7 insert mode completion when text is changed
+    acmds->add({bufnr: bnr,
+		event: 'TextChangedI',
+		group: 'LSPBufferAutocmds',
+		cmd: 'LspComplete()'})
+  endif
+
+  if LspOmniComplEnabled(ftype)
+    setbufvar(bnr, '&omnifunc', 'g:LspOmniFunc')
+  endif
+
+  if lspserver.completionLazyDoc
+    # resolve additional documentation for a selected item
+    acmds->add({bufnr: bnr,
+                event: 'CompleteChanged',
+                group: 'LSPBufferAutocmds',
+                cmd: 'LspResolve()'})
+  endif
+
+  acmds->add({bufnr: bnr,
+	      event: 'CompleteChanged',
+	      group: 'LSPBufferAutocmds',
+	      cmd: 'LspSetPopupFileType()'})
+
+  # Execute LSP server initiated text edits after completion
+  acmds->add({bufnr: bnr,
+	      event: 'CompleteDone',
+	      group: 'LSPBufferAutocmds',
+	      cmd: $'LspCompleteDone({bnr})'})
+
+  autocmd_add(acmds)
+enddef
+
+# Buffer "bnr" is loaded in a window.  If omni-completion is enabled for this
+# buffer, then set the 'omnifunc' option.
+export def BufferLoadedInWin(bnr: number)
+  if !opt.lspOptions.autoComplete
+      && LspOmniComplEnabled(bnr->getbufvar('&filetype'))
+    setbufvar(bnr, '&omnifunc', 'g:LspOmniFunc')
+  endif
+enddef
+
+# vim: tabstop=8 shiftwidth=2 softtabstop=2
diff --git a/vim/pack/downloads/opt/lsp/autoload/lsp/diag.vim b/vim/pack/downloads/opt/lsp/autoload/lsp/diag.vim
new file mode 100644
index 0000000..6975edf
--- /dev/null
+++ b/vim/pack/downloads/opt/lsp/autoload/lsp/diag.vim
@@ -0,0 +1,920 @@
+vim9script
+
+# Functions related to handling LSP diagnostics.
+
+import './options.vim' as opt
+import './buffer.vim' as buf
+import './util.vim'
+
+# [bnr] = {
+#   serverDiagnostics: {
+#     lspServer1Id: [diag, diag, diag]
+#     lspServer2Id: [diag, diag, diag]
+#   },
+#   serverDiagnosticsByLnum: {
+#     lspServer1Id: { [lnum]: [diag, diag diag] },
+#     lspServer2Id: { [lnum]: [diag, diag diag] },
+#   },
+#   sortedDiagnostics: [lspServer1.diags, ...lspServer2.diags]->sort()
+# }
+var diagsMap: dict<dict<any>> = {}
+
+# Initialize the signs and the text property type used for diagnostics.
+export def InitOnce()
+  # Signs and their highlight groups used for LSP diagnostics
+  hlset([
+    {name: 'LspDiagLine', default: true, linksto: 'NONE'},
+    {name: 'LspDiagSignErrorText', default: true, linksto: 'ErrorMsg'},
+    {name: 'LspDiagSignWarningText', default: true, linksto: 'Search'},
+    {name: 'LspDiagSignInfoText', default: true, linksto: 'Pmenu'},
+    {name: 'LspDiagSignHintText', default: true, linksto: 'Question'}
+  ])
+  sign_define([
+    {
+      name: 'LspDiagError',
+      text: opt.lspOptions.diagSignErrorText,
+      texthl: 'LspDiagSignErrorText',
+      linehl: 'LspDiagLine'
+    },
+    {
+      name: 'LspDiagWarning',
+      text: opt.lspOptions.diagSignWarningText,
+      texthl: 'LspDiagSignWarningText',
+      linehl: 'LspDiagLine'
+    },
+    {
+      name: 'LspDiagInfo',
+      text: opt.lspOptions.diagSignInfoText,
+      texthl: 'LspDiagSignInfoText',
+      linehl: 'LspDiagLine'
+    },
+    {
+      name: 'LspDiagHint',
+      text: opt.lspOptions.diagSignHintText,
+      texthl: 'LspDiagSignHintText',
+      linehl: 'LspDiagLine'
+    }
+  ])
+
+  # Diag inline highlight groups and text property types
+  hlset([
+    {name: 'LspDiagInlineError', default: true, linksto: 'SpellBad'},
+    {name: 'LspDiagInlineWarning', default: true, linksto: 'SpellCap'},
+    {name: 'LspDiagInlineInfo', default: true, linksto: 'SpellRare'},
+    {name: 'LspDiagInlineHint', default: true, linksto: 'SpellLocal'}
+  ])
+
+  var override = &cursorline
+      && &cursorlineopt =~ '\<line\>\|\<screenline\>\|\<both\>'
+
+  prop_type_add('LspDiagInlineError',
+		{highlight: 'LspDiagInlineError',
+		 priority: 10,
+		 override: override})
+  prop_type_add('LspDiagInlineWarning',
+		{highlight: 'LspDiagInlineWarning',
+		 priority: 9,
+		 override: override})
+  prop_type_add('LspDiagInlineInfo',
+		{highlight: 'LspDiagInlineInfo',
+		 priority: 8,
+		 override: override})
+  prop_type_add('LspDiagInlineHint',
+		{highlight: 'LspDiagInlineHint',
+		 priority: 7,
+		 override: override})
+
+  # Diag virtual text highlight groups and text property types
+  hlset([
+    {name: 'LspDiagVirtualTextError', default: true, linksto: 'SpellBad'},
+    {name: 'LspDiagVirtualTextWarning', default: true, linksto: 'SpellCap'},
+    {name: 'LspDiagVirtualTextInfo', default: true, linksto: 'SpellRare'},
+    {name: 'LspDiagVirtualTextHint', default: true, linksto: 'SpellLocal'},
+  ])
+  prop_type_add('LspDiagVirtualTextError',
+		{highlight: 'LspDiagVirtualTextError', override: true})
+  prop_type_add('LspDiagVirtualTextWarning',
+		{highlight: 'LspDiagVirtualTextWarning', override: true})
+  prop_type_add('LspDiagVirtualTextInfo',
+		{highlight: 'LspDiagVirtualTextInfo', override: true})
+  prop_type_add('LspDiagVirtualTextHint',
+		{highlight: 'LspDiagVirtualTextHint', override: true})
+
+  autocmd_add([{group: 'LspCmds',
+	        event: 'User',
+		pattern: 'LspOptionsChanged',
+		cmd: 'LspDiagsOptionsChanged()'}])
+
+  # ALE plugin support
+  if opt.lspOptions.aleSupport
+    opt.lspOptions.autoHighlightDiags = false
+    autocmd_add([
+      {
+	group: 'LspAleCmds',
+	event: 'User',
+	pattern: 'ALEWantResults',
+	cmd: 'AleHook(g:ale_want_results_buffer)'
+      }
+    ])
+  endif
+enddef
+
+# Initialize the diagnostics features for the buffer 'bnr'
+export def BufferInit(lspserver: dict<any>, bnr: number)
+  if opt.lspOptions.showDiagInBalloon
+    :set ballooneval balloonevalterm
+    setbufvar(bnr, '&balloonexpr', 'g:LspDiagExpr()')
+  endif
+
+  var acmds: list<dict<any>> = []
+  # Show diagnostics on the status line
+  if opt.lspOptions.showDiagOnStatusLine
+    acmds->add({bufnr: bnr,
+		event: 'CursorMoved',
+		group: 'LSPBufferAutocmds',
+		cmd: 'ShowCurrentDiagInStatusLine()'})
+  endif
+  autocmd_add(acmds)
+enddef
+
+# Function to sort the diagnostics in ascending order based on the line and
+# character offset
+def DiagsSortFunc(a: dict<any>, b: dict<any>): number
+  var a_start: dict<number> = a.range.start
+  var b_start: dict<number> = b.range.start
+  var linediff: number = a_start.line - b_start.line
+  if linediff == 0
+    return a_start.character - b_start.character
+  endif
+  return linediff
+enddef
+
+# Sort diagnostics ascending based on line and character offset
+def SortDiags(diags: list<dict<any>>): list<dict<any>>
+  return diags->sort(DiagsSortFunc)
+enddef
+
+# Remove the diagnostics stored for buffer "bnr"
+export def DiagRemoveFile(bnr: number)
+  if diagsMap->has_key(bnr)
+    diagsMap->remove(bnr)
+  endif
+enddef
+
+def DiagSevToSignName(severity: number): string
+  var typeMap: list<string> = ['LspDiagError', 'LspDiagWarning',
+						'LspDiagInfo', 'LspDiagHint']
+  if severity > 4
+    return 'LspDiagHint'
+  endif
+  return typeMap[severity - 1]
+enddef
+
+def DiagSevToInlineHLName(severity: number): string
+  var typeMap: list<string> = [
+    'LspDiagInlineError',
+    'LspDiagInlineWarning',
+    'LspDiagInlineInfo',
+    'LspDiagInlineHint'
+  ]
+  if severity > 4
+    return 'LspDiagInlineHint'
+  endif
+  return typeMap[severity - 1]
+enddef
+
+def DiagSevToVirtualTextHLName(severity: number): string
+  var typeMap: list<string> = [
+    'LspDiagVirtualTextError',
+    'LspDiagVirtualTextWarning',
+    'LspDiagVirtualTextInfo',
+    'LspDiagVirtualTextHint'
+  ]
+  if severity > 4
+    return 'LspDiagVirtualTextHint'
+  endif
+  return typeMap[severity - 1]
+enddef
+
+def DiagSevToSymbolText(severity: number): string
+  var lspOpts = opt.lspOptions
+  var typeMap: list<string> = [
+    lspOpts.diagSignErrorText,
+    lspOpts.diagSignWarningText,
+    lspOpts.diagSignInfoText,
+    lspOpts.diagSignHintText
+  ]
+  if severity > 4
+    return lspOpts.diagSignHintText
+  endif
+  return typeMap[severity - 1]
+enddef
+
+# Remove signs and text properties for diagnostics in buffer
+def RemoveDiagVisualsForBuffer(bnr: number, all: bool = false)
+  var lspOpts = opt.lspOptions
+  if lspOpts.showDiagWithSign || all
+    # Remove all the existing diagnostic signs
+    sign_unplace('LSPDiag', {buffer: bnr})
+  endif
+
+  if lspOpts.showDiagWithVirtualText || all
+    # Remove all the existing virtual text
+    prop_remove({type: 'LspDiagVirtualTextError', bufnr: bnr, all: true})
+    prop_remove({type: 'LspDiagVirtualTextWarning', bufnr: bnr, all: true})
+    prop_remove({type: 'LspDiagVirtualTextInfo', bufnr: bnr, all: true})
+    prop_remove({type: 'LspDiagVirtualTextHint', bufnr: bnr, all: true})
+  endif
+
+  if lspOpts.highlightDiagInline || all
+    # Remove all the existing virtual text
+    prop_remove({type: 'LspDiagInlineError', bufnr: bnr, all: true})
+    prop_remove({type: 'LspDiagInlineWarning', bufnr: bnr, all: true})
+    prop_remove({type: 'LspDiagInlineInfo', bufnr: bnr, all: true})
+    prop_remove({type: 'LspDiagInlineHint', bufnr: bnr, all: true})
+  endif
+enddef
+
+# Refresh the placed diagnostics in buffer "bnr"
+# This inline signs, inline props, and virtual text diagnostics
+export def DiagsRefresh(bnr: number, all: bool = false)
+  var lspOpts = opt.lspOptions
+  if !lspOpts.autoHighlightDiags
+    return
+  endif
+
+  :silent! bnr->bufload()
+
+  RemoveDiagVisualsForBuffer(bnr, all)
+
+  if !diagsMap->has_key(bnr) ||
+      diagsMap[bnr].sortedDiagnostics->empty()
+    return
+  endif
+
+  # Initialize default/fallback properties for diagnostic virtual text:
+  var diag_align: string = 'above'
+  var diag_wrap: string = 'truncate'
+  var diag_symbol: string = '┌─'
+
+  if lspOpts.diagVirtualTextAlign == 'below'
+    diag_align = 'below'
+    diag_wrap = 'truncate'
+    diag_symbol = '└─'
+  elseif lspOpts.diagVirtualTextAlign == 'after'
+    diag_align = 'after'
+    diag_wrap = 'wrap'
+    diag_symbol = 'E>'
+  endif
+
+  if lspOpts.diagVirtualTextWrap != 'default'
+    diag_wrap = lspOpts.diagVirtualTextWrap
+  endif
+
+  var signs: list<dict<any>> = []
+  var diags: list<dict<any>> = diagsMap[bnr].sortedDiagnostics
+  var inlineHLprops: list<list<list<number>>> = [[], [], [], [], []]
+  for diag in diags
+    # TODO: prioritize most important severity if there are multiple
+    # diagnostics from the same line
+    var d_range = diag.range
+    var d_start = d_range.start
+    var d_end = d_range.end
+    var lnum = d_start.line + 1
+    if lspOpts.showDiagWithSign
+      signs->add({id: 0, buffer: bnr, group: 'LSPDiag',
+		  lnum: lnum, name: DiagSevToSignName(diag.severity),
+		  priority: 10 - diag.severity})
+    endif
+
+    try
+      if lspOpts.highlightDiagInline
+	var propLocation: list<number> = [
+	  lnum, util.GetLineByteFromPos(bnr, d_start) + 1,
+	  d_end.line + 1, util.GetLineByteFromPos(bnr, d_end) + 1
+	]
+	inlineHLprops[diag.severity]->add(propLocation)
+      endif
+
+      if lspOpts.showDiagWithVirtualText
+        var padding: number
+        var symbol: string = diag_symbol
+
+        if diag_align == 'after'
+          padding = 3
+          symbol = DiagSevToSymbolText(diag.severity)
+        else
+	  var charIdx = util.GetCharIdxWithoutCompChar(bnr, d_start)
+          padding = charIdx
+          if padding > 0
+            padding = strdisplaywidth(getline(lnum)[ : charIdx - 1])
+          endif
+        endif
+
+        prop_add(lnum, 0, {bufnr: bnr,
+			   type: DiagSevToVirtualTextHLName(diag.severity),
+                           text: $'{symbol} {diag.message}',
+                           text_align: diag_align,
+                           text_wrap: diag_wrap,
+                           text_padding_left: padding})
+      endif
+    catch /E966\|E964/ # Invalid lnum | Invalid col
+      # Diagnostics arrive asynchronously and the document changed while they
+      # were in transit. Ignore this as new once will arrive shortly.
+    endtry
+  endfor
+
+  if lspOpts.highlightDiagInline
+    for i in range(1, 4)
+      if !inlineHLprops[i]->empty()
+	try
+	  prop_add_list({bufnr: bnr, type: DiagSevToInlineHLName(i)},
+	    inlineHLprops[i])
+	catch /E966\|E964/ # Invalid lnum | Invalid col
+	endtry
+      endif
+    endfor
+  endif
+
+  if lspOpts.showDiagWithSign
+    signs->sign_placelist()
+  endif
+enddef
+
+# Sends diagnostics to Ale
+def SendAleDiags(bnr: number, timerid: number)
+  if !diagsMap->has_key(bnr)
+    return
+  endif
+
+  # Convert to Ale's diagnostics format (:h ale-loclist-format)
+  ale#other_source#ShowResults(bnr, 'lsp',
+    diagsMap[bnr].sortedDiagnostics->mapnew((_, v) => {
+     return {text: v.message,
+             lnum: v.range.start.line + 1,
+             col: util.GetLineByteFromPos(bnr, v.range.start) + 1,
+             end_lnum: v.range.end.line + 1,
+             end_col: util.GetLineByteFromPos(bnr, v.range.end) + 1,
+             type: "EWIH"[v.severity - 1]}
+    })
+  )
+enddef
+
+# Hook called when Ale wants to retrieve new diagnostics
+def AleHook(bnr: number)
+  ale#other_source#StartChecking(bnr, 'lsp')
+  timer_start(0, function('SendAleDiags', [bnr]))
+enddef
+
+# New LSP diagnostic messages received from the server for a file.
+# Update the signs placed in the buffer for this file
+export def ProcessNewDiags(bnr: number)
+  DiagsUpdateLocList(bnr)
+
+  var lspOpts = opt.lspOptions
+  if lspOpts.aleSupport
+    SendAleDiags(bnr, -1)
+  endif
+
+  if bnr == -1 || !diagsMap->has_key(bnr)
+    return
+  endif
+
+  var curmode: string = mode()
+  if curmode == 'i' || curmode == 'R' || curmode == 'Rv'
+    # postpone placing signs in insert mode and replace mode. These will be
+    # placed after the user returns to Normal mode.
+    setbufvar(bnr, 'LspDiagsUpdatePending', true)
+    return
+  endif
+
+  DiagsRefresh(bnr)
+enddef
+
+# process a diagnostic notification message from the LSP server
+# Notification: textDocument/publishDiagnostics
+# Param: PublishDiagnosticsParams
+export def DiagNotification(lspserver: dict<any>, uri: string, diags_arg: list<dict<any>>): void
+  # Diagnostics are disabled for this server?
+  if !lspserver.featureEnabled('diagnostics')
+    return
+  endif
+
+  var fname: string = util.LspUriToFile(uri)
+  var bnr: number = fname->bufnr()
+  if bnr == -1
+    # Is this condition possible?
+    return
+  endif
+
+  var newDiags: list<dict<any>> = diags_arg
+
+  if lspserver.needOffsetEncoding
+    # Decode the position encoding in all the diags
+    newDiags->map((_, dval) => {
+	lspserver.decodeRange(bnr, dval.range)
+	return dval
+      })
+  endif
+
+  if lspserver.processDiagHandler != null_function
+    newDiags = lspserver.processDiagHandler(diags_arg)
+  endif
+
+  # TODO: Is the buffer (bnr) always a loaded buffer? Should we load it here?
+  var lastlnum: number = bnr->getbufinfo()[0].linecount
+
+  # store the diagnostic for each line separately
+  var diagsByLnum: dict<list<dict<any>>> = {}
+
+  var diagWithinRange: list<dict<any>> = []
+  for diag in newDiags
+    var d_start = diag.range.start
+    if d_start.line + 1 > lastlnum
+      # Make sure the line number is a valid buffer line number
+      d_start.line = lastlnum - 1
+    endif
+
+    var lnum = d_start.line + 1
+    if !diagsByLnum->has_key(lnum)
+      diagsByLnum[lnum] = []
+    endif
+    diagsByLnum[lnum]->add(diag)
+
+    diagWithinRange->add(diag)
+  endfor
+
+  var serverDiags: dict<list<any>> = diagsMap->has_key(bnr) ?
+      diagsMap[bnr].serverDiagnostics : {}
+  serverDiags[lspserver.id] = diagWithinRange
+
+  var serverDiagsByLnum: dict<dict<list<any>>> = diagsMap->has_key(bnr) ?
+      diagsMap[bnr].serverDiagnosticsByLnum : {}
+  serverDiagsByLnum[lspserver.id] = diagsByLnum
+
+  # store the diagnostic for each line separately
+  var joinedServerDiags: list<dict<any>> = []
+  for diags in serverDiags->values()
+    joinedServerDiags->extend(diags)
+  endfor
+
+  var sortedDiags = SortDiags(joinedServerDiags)
+
+  diagsMap[bnr] = {
+    sortedDiagnostics: sortedDiags,
+    serverDiagnosticsByLnum: serverDiagsByLnum,
+    serverDiagnostics: serverDiags
+  }
+
+  ProcessNewDiags(bnr)
+
+  # Notify user scripts that diags has been updated
+  if exists('#User#LspDiagsUpdated')
+    :doautocmd <nomodeline> User LspDiagsUpdated
+  endif
+enddef
+
+# get the count of error in the current buffer
+export def DiagsGetErrorCount(bnr: number): dict<number>
+  var diagSevCount: list<number> = [0, 0, 0, 0, 0]
+  if diagsMap->has_key(bnr)
+    var diags = diagsMap[bnr].sortedDiagnostics
+    for diag in diags
+      var severity = diag->get('severity', 0)
+      diagSevCount[severity] += 1
+    endfor
+  endif
+
+  return {
+    Error: diagSevCount[1],
+    Warn: diagSevCount[2],
+    Info: diagSevCount[3],
+    Hint: diagSevCount[4]
+  }
+enddef
+
+# Map the LSP DiagnosticSeverity to a quickfix type character
+def DiagSevToQfType(severity: number): string
+  var typeMap: list<string> = ['E', 'W', 'I', 'N']
+
+  if severity > 4
+    return ''
+  endif
+
+  return typeMap[severity - 1]
+enddef
+
+# Update the location list window for the current window with the diagnostic
+# messages.
+# Returns true if diagnostics is not empty and false if it is empty.
+def DiagsUpdateLocList(bnr: number, calledByCmd: bool = false): bool
+  var fname: string = bnr->bufname()->fnamemodify(':p')
+  if fname->empty()
+    return false
+  endif
+
+  var LspQfId: number = bnr->getbufvar('LspQfId', 0)
+  if LspQfId == 0 && !opt.lspOptions.autoPopulateDiags && !calledByCmd
+    # Diags location list is not present. Create the location list only if
+    # the 'autoPopulateDiags' option is set or the ":LspDiag show" command is
+    # invoked.
+    return false
+  endif
+
+  if LspQfId != 0 && getloclist(0, {id: LspQfId}).id != LspQfId
+    # Previously used location list for the diagnostics is gone
+    LspQfId = 0
+  endif
+
+  if !diagsMap->has_key(bnr) ||
+      diagsMap[bnr].sortedDiagnostics->empty()
+    if LspQfId != 0
+      setloclist(0, [], 'r', {id: LspQfId, items: []})
+    endif
+    return false
+  endif
+
+  var qflist: list<dict<any>> = []
+  var text: string
+
+  var diags = diagsMap[bnr].sortedDiagnostics
+  for diag in diags
+    var d_range = diag.range
+    var d_start = d_range.start
+    var d_end = d_range.end
+    text = diag.message->substitute("\n\\+", "\n", 'g')
+    qflist->add({filename: fname,
+		    lnum: d_start.line + 1,
+		    col: util.GetLineByteFromPos(bnr, d_start) + 1,
+		    end_lnum: d_end.line + 1,
+                    end_col: util.GetLineByteFromPos(bnr, d_end) + 1,
+		    text: text,
+		    type: DiagSevToQfType(diag.severity)})
+  endfor
+
+  var op: string = ' '
+  var props = {title: 'Language Server Diagnostics', items: qflist}
+  if LspQfId != 0
+    op = 'r'
+    props.id = LspQfId
+  endif
+  setloclist(0, [], op, props)
+  if LspQfId == 0
+    setbufvar(bnr, 'LspQfId', getloclist(0, {id: 0}).id)
+  endif
+
+  return true
+enddef
+
+# Display the diagnostic messages from the LSP server for the current buffer
+# in a location list
+export def ShowAllDiags(): void
+  var bnr: number = bufnr()
+  if !DiagsUpdateLocList(bnr, true)
+    util.WarnMsg($'No diagnostic messages found for {@%}')
+    return
+  endif
+
+  var save_winid = win_getid()
+  # make the diagnostics error list the active one and open it
+  var LspQfId: number = bnr->getbufvar('LspQfId', 0)
+  var LspQfNr: number = getloclist(0, {id: LspQfId, nr: 0}).nr
+  exe $':{LspQfNr} lhistory'
+  :lopen
+  if !opt.lspOptions.keepFocusInDiags
+    save_winid->win_gotoid()
+  endif
+enddef
+
+# Display the message of "diag" in a popup window right below the position in
+# the diagnostic message.
+def ShowDiagInPopup(diag: dict<any>)
+  var d_start = diag.range.start
+  var dlnum = d_start.line + 1
+  var ltext = dlnum->getline()
+  var dlcol = ltext->byteidxcomp(d_start.character) + 1
+
+  var lastline = line('$')
+  if dlnum > lastline
+    # The line number is outside the last line in the file.
+    dlnum = lastline
+  endif
+  if dlcol < 1
+    # The column is outside the last character in line.
+    dlcol = ltext->len() + 1
+  endif
+  var d = screenpos(0, dlnum, dlcol)
+  if d->empty()
+    # If the diag position cannot be converted to Vim lnum/col, then use
+    # the current cursor position
+    d = {row: line('.'), col: col('.')}
+  endif
+
+  # Display a popup right below the diagnostics position
+  var msg = diag.message->split("\n")
+  var msglen = msg->reduce((acc, val) => max([acc, val->strcharlen()]), 0)
+
+  var ppopts = {}
+  ppopts.pos = 'topleft'
+  ppopts.line = d.row + 1
+  ppopts.moved = 'any'
+
+  if msglen > &columns
+    ppopts.wrap = true
+    ppopts.col = 1
+  else
+    ppopts.wrap = false
+    ppopts.col = d.col
+  endif
+
+  popup_create(msg, ppopts)
+enddef
+
+# Display the "diag" message in a popup or in the status message area
+def DisplayDiag(diag: dict<any>)
+  if opt.lspOptions.showDiagInPopup
+    # Display the diagnostic message in a popup window.
+    ShowDiagInPopup(diag)
+  else
+    # Display the diagnostic message in the status message area
+    :echo diag.message
+  endif
+enddef
+
+# Show the diagnostic message for the current line
+export def ShowCurrentDiag(atPos: bool)
+  var bnr: number = bufnr()
+  var lnum: number = line('.')
+  var col: number = charcol('.')
+  var diag: dict<any> = GetDiagByPos(bnr, lnum, col, atPos)
+  if diag->empty()
+    util.WarnMsg($'No diagnostic messages found for current {atPos ? "position" : "line"}')
+  else
+    DisplayDiag(diag)
+  endif
+enddef
+
+# Show the diagnostic message for the current line without linebreak
+def ShowCurrentDiagInStatusLine()
+  var bnr: number = bufnr()
+  var lnum: number = line('.')
+  var col: number = charcol('.')
+  var diag: dict<any> = GetDiagByPos(bnr, lnum, col)
+  if !diag->empty()
+    # 15 is a enough length not to cause line break
+    var max_width = &columns - 15
+    var code = ''
+    if diag->has_key('code')
+      code = $'[{diag.code}] '
+    endif
+    var msgNoLineBreak = code ..
+	diag.message->substitute("\n", ' ', '')->substitute("\\n", ' ', '')
+    :echo msgNoLineBreak[ : max_width]
+  else
+    # clear the previous message
+    :echo ''
+  endif
+enddef
+
+# Get the diagnostic from the LSP server for a particular line and character
+# offset in a file
+export def GetDiagByPos(bnr: number, lnum: number, col: number,
+			atPos: bool = false): dict<any>
+  var diags_in_line = GetDiagsByLine(bnr, lnum)
+
+  for diag in diags_in_line
+    var r = diag.range
+    var startCharIdx = util.GetCharIdxWithoutCompChar(bnr, r.start)
+    var endCharIdx = util.GetCharIdxWithoutCompChar(bnr, r.end)
+    if atPos
+      if col >= startCharIdx + 1 && col < endCharIdx + 1
+        return diag
+      endif
+    elseif col <= startCharIdx + 1
+      return diag
+    endif
+  endfor
+
+  # No diagnostic to the right of the position, return the last one instead
+  if !atPos && diags_in_line->len() > 0
+    return diags_in_line[-1]
+  endif
+
+  return {}
+enddef
+
+# Get all diagnostics from the LSP server for a particular line in a file
+export def GetDiagsByLine(bnr: number, lnum: number, lspserver: dict<any> = null_dict): list<dict<any>>
+  if !diagsMap->has_key(bnr)
+    return []
+  endif
+
+  var diags: list<dict<any>> = []
+
+  var serverDiagsByLnum = diagsMap[bnr].serverDiagnosticsByLnum
+
+  if lspserver == null_dict
+    for diagsByLnum in serverDiagsByLnum->values()
+      if diagsByLnum->has_key(lnum)
+        diags->extend(diagsByLnum[lnum])
+      endif
+    endfor
+  else
+    if !serverDiagsByLnum->has_key(lspserver.id)
+      return []
+    endif
+    if serverDiagsByLnum[lspserver.id]->has_key(lnum)
+      diags = serverDiagsByLnum[lspserver.id][lnum]
+    endif
+  endif
+
+  return diags->sort((a, b) => {
+    return a.range.start.character - b.range.start.character
+  })
+enddef
+
+# Utility function to do the actual jump
+def JumpDiag(diag: dict<any>)
+  var startPos: dict<number> = diag.range.start
+  setcursorcharpos(startPos.line + 1,
+		   util.GetCharIdxWithoutCompChar(bufnr(), startPos) + 1)
+  :normal! zv
+  if !opt.lspOptions.showDiagWithVirtualText
+    :redraw
+    DisplayDiag(diag)
+  endif
+enddef
+
+# jump to the next/previous/first diagnostic message in the current buffer
+export def LspDiagsJump(which: string, a_count: number = 0): void
+  var fname: string = expand('%:p')
+  if fname->empty()
+    return
+  endif
+  var bnr: number = bufnr()
+
+  if !diagsMap->has_key(bnr) ||
+      diagsMap[bnr].sortedDiagnostics->empty()
+    util.WarnMsg($'No diagnostic messages found for {fname}')
+    return
+  endif
+
+  var diags = diagsMap[bnr].sortedDiagnostics
+
+  if which == 'first'
+    JumpDiag(diags[0])
+    return
+  endif
+
+  if which == 'last'
+    JumpDiag(diags[-1])
+    return
+  endif
+
+  # Find the entry just before the current line (binary search)
+  var count = a_count > 1 ? a_count : 1
+  var curlnum: number = line('.')
+  var curcol: number = charcol('.')
+  for diag in (which == 'next' || which == 'nextWrap' || which == 'here') ?
+					diags : diags->copy()->reverse()
+    var d_start = diag.range.start
+    var lnum = d_start.line + 1
+    var col = util.GetCharIdxWithoutCompChar(bnr, d_start) + 1
+    if ((which == 'next' || which == 'nextWrap') && (lnum > curlnum || lnum == curlnum && col > curcol))
+	  || ((which == 'prev' || which == 'prevWrap') && (lnum < curlnum || lnum == curlnum
+							&& col < curcol))
+	  || (which == 'here' && (lnum == curlnum && col >= curcol))
+
+      # Skip over as many diags as "count" dictates
+      count = count - 1
+      if count > 0
+        continue
+      endif
+
+      JumpDiag(diag)
+      return
+    endif
+  endfor
+
+  # If [count] exceeded the remaining diags
+  if ((which == 'next' || which == 'nextWrap') && a_count > 1 && a_count != count)
+    JumpDiag(diags[-1])
+    return
+  endif
+
+  # If [count] exceeded the previous diags
+  if ((which == 'prev' || which == 'prevWrap') && a_count > 1 && a_count != count)
+    JumpDiag(diags[0])
+    return
+  endif
+
+  if which == 'nextWrap' || which == 'prevWrap'
+    JumpDiag(diags[which == 'nextWrap' ? 0 : -1])
+    return
+  endif
+
+  if which == 'here'
+    util.WarnMsg('No more diagnostics found on this line')
+  else
+    util.WarnMsg('No more diagnostics found')
+  endif
+enddef
+
+# Return the sorted diagnostics for buffer "bnr".  Default is the current
+# buffer.  A copy of the diagnostics is returned so that the caller can modify
+# the diagnostics.
+export def GetDiagsForBuf(bnr: number = bufnr()): list<dict<any>>
+  if !diagsMap->has_key(bnr) ||
+      diagsMap[bnr].sortedDiagnostics->empty()
+    return []
+  endif
+
+  return diagsMap[bnr].sortedDiagnostics->deepcopy()
+enddef
+
+# Return the diagnostic text from the LSP server for the current mouse line to
+# display in a balloon
+def g:LspDiagExpr(): any
+  if !opt.lspOptions.showDiagInBalloon
+    return ''
+  endif
+
+  var diagsInfo: list<dict<any>> =
+			GetDiagsByLine(v:beval_bufnr, v:beval_lnum)
+  if diagsInfo->empty()
+    # No diagnostic for the current cursor location
+    return ''
+  endif
+  var diagFound: dict<any> = {}
+  for diag in diagsInfo
+    var r = diag.range
+    var startcol = util.GetLineByteFromPos(v:beval_bufnr, r.start) + 1
+    var endcol = util.GetLineByteFromPos(v:beval_bufnr, r.end) + 1
+    if v:beval_col >= startcol && v:beval_col < endcol
+      diagFound = diag
+      break
+    endif
+  endfor
+  if diagFound->empty()
+    # mouse is outside of the diagnostics range
+    return ''
+  endif
+
+  # return the found diagnostic
+  return diagFound.message->split("\n")
+enddef
+
+# Track the current diagnostics auto highlight enabled/disabled state.  Used
+# when the "autoHighlightDiags" option value is changed.
+var save_autoHighlightDiags = opt.lspOptions.autoHighlightDiags
+var save_highlightDiagInline = opt.lspOptions.highlightDiagInline
+var save_showDiagWithSign = opt.lspOptions.showDiagWithSign
+var save_showDiagWithVirtualText = opt.lspOptions.showDiagWithVirtualText
+
+# Enable the LSP diagnostics highlighting
+export def DiagsHighlightEnable()
+  opt.lspOptions.autoHighlightDiags = true
+  save_autoHighlightDiags = true
+  for binfo in getbufinfo({bufloaded: true})
+    if diagsMap->has_key(binfo.bufnr)
+      DiagsRefresh(binfo.bufnr)
+    endif
+  endfor
+enddef
+
+# Disable the LSP diagnostics highlighting in all the buffers
+export def DiagsHighlightDisable()
+  # turn off all diags highlight
+  opt.lspOptions.autoHighlightDiags = false
+  save_autoHighlightDiags = false
+  for binfo in getbufinfo()
+    if diagsMap->has_key(binfo.bufnr)
+      RemoveDiagVisualsForBuffer(binfo.bufnr)
+    endif
+  endfor
+enddef
+
+# Some options are changed.  If 'autoHighlightDiags' option is changed, then
+# either enable or disable diags auto highlight.
+export def LspDiagsOptionsChanged()
+  if save_autoHighlightDiags && !opt.lspOptions.autoHighlightDiags
+    DiagsHighlightDisable()
+  elseif !save_autoHighlightDiags && opt.lspOptions.autoHighlightDiags
+    DiagsHighlightEnable()
+  endif
+
+  if save_highlightDiagInline != opt.lspOptions.highlightDiagInline
+    || save_showDiagWithSign != opt.lspOptions.showDiagWithSign
+    || save_showDiagWithVirtualText != opt.lspOptions.showDiagWithVirtualText
+    save_highlightDiagInline = opt.lspOptions.highlightDiagInline
+    save_showDiagWithSign = opt.lspOptions.showDiagWithSign
+    save_showDiagWithVirtualText = opt.lspOptions.showDiagWithVirtualText
+    for binfo in getbufinfo({bufloaded: true})
+      if diagsMap->has_key(binfo.bufnr)
+	DiagsRefresh(binfo.bufnr, true)
+      endif
+    endfor
+  endif
+enddef
+
+# vim: tabstop=8 shiftwidth=2 softtabstop=2
diff --git a/vim/pack/downloads/opt/lsp/autoload/lsp/handlers.vim b/vim/pack/downloads/opt/lsp/autoload/lsp/handlers.vim
new file mode 100644
index 0000000..dd597ed
--- /dev/null
+++ b/vim/pack/downloads/opt/lsp/autoload/lsp/handlers.vim
@@ -0,0 +1,305 @@
+vim9script
+
+# Handlers for messages from the LSP server
+# Refer to https://microsoft.github.io/language-server-protocol/specification
+# for the Language Server Protocol (LSP) specification.
+
+import './util.vim'
+import './diag.vim'
+import './textedit.vim'
+
+# Process various reply messages from the LSP server
+export def ProcessReply(lspserver: dict<any>, req: dict<any>, reply: dict<any>): void
+  util.ErrMsg($'Unsupported reply received from LSP server: {reply->string()} for request: {req->string()}')
+enddef
+
+# process a diagnostic notification message from the LSP server
+# Notification: textDocument/publishDiagnostics
+# Param: PublishDiagnosticsParams
+def ProcessDiagNotif(lspserver: dict<any>, reply: dict<any>): void
+  var params = reply.params
+  diag.DiagNotification(lspserver, params.uri, params.diagnostics)
+enddef
+
+# Convert LSP message type to a string
+def LspMsgTypeToString(lspMsgType: number): string
+  var msgStrMap: list<string> = ['', 'Error', 'Warning', 'Info', 'Log']
+  var mtype: string = 'Log'
+  if lspMsgType > 0 && lspMsgType < 5
+    mtype = msgStrMap[lspMsgType]
+  endif
+  return mtype
+enddef
+
+# process a show notification message from the LSP server
+# Notification: window/showMessage
+# Param: ShowMessageParams
+def ProcessShowMsgNotif(lspserver: dict<any>, reply: dict<any>)
+  var msgType = reply.params.type
+  if msgType >= 4
+    # ignore log messages from the LSP server (too chatty)
+    # TODO: Add a configuration to control the message level that will be
+    # displayed. Also store these messages and provide a command to display
+    # them.
+    return
+  endif
+  if msgType == 1
+    util.ErrMsg($'Lsp({lspserver.name}) {reply.params.message}')
+  elseif msgType == 2
+    util.WarnMsg($'Lsp({lspserver.name}) {reply.params.message}')
+  elseif msgType == 3
+    util.InfoMsg($'Lsp({lspserver.name}) {reply.params.message}')
+  endif
+enddef
+
+# process a log notification message from the LSP server
+# Notification: window/logMessage
+# Param: LogMessageParams
+def ProcessLogMsgNotif(lspserver: dict<any>, reply: dict<any>)
+  var params = reply.params
+  var mtype = LspMsgTypeToString(params.type)
+  lspserver.addMessage(mtype, params.message)
+enddef
+
+# process the log trace notification messages
+# Notification: $/logTrace
+# Param: LogTraceParams
+def ProcessLogTraceNotif(lspserver: dict<any>, reply: dict<any>)
+  lspserver.addMessage('trace', reply.params.message)
+enddef
+
+# process unsupported notification messages
+def ProcessUnsupportedNotif(lspserver: dict<any>, reply: dict<any>)
+  util.WarnMsg($'Unsupported notification message received from the LSP server ({lspserver.name}), message = {reply->string()}')
+enddef
+
+# Dict to process telemetry notification messages only once per filetype
+var telemetryProcessed: dict<bool> = {}
+# process unsupported notification messages only once
+def ProcessUnsupportedNotifOnce(lspserver: dict<any>, reply: dict<any>)
+  if !telemetryProcessed->get(&ft, false)
+    ProcessUnsupportedNotif(lspserver, reply)
+    telemetryProcessed->extend({[&ft]: true})
+  endif
+enddef
+
+# process notification messages from the LSP server
+export def ProcessNotif(lspserver: dict<any>, reply: dict<any>): void
+  var lsp_notif_handlers: dict<func> =
+    {
+      'window/showMessage': ProcessShowMsgNotif,
+      'window/logMessage': ProcessLogMsgNotif,
+      'textDocument/publishDiagnostics': ProcessDiagNotif,
+      '$/logTrace': ProcessLogTraceNotif,
+      'telemetry/event': ProcessUnsupportedNotifOnce,
+    }
+
+  # Explicitly ignored notification messages (many of them are specific to a
+  # particular language server)
+  var lsp_ignored_notif_handlers: list<string> =
+    [
+      '$/progress',
+      '$/status/report',
+      '$/status/show',
+      # PHP intelephense server sends the "indexingStarted" and
+      # "indexingEnded" notifications which is not in the LSP specification.
+      'indexingStarted',
+      'indexingEnded',
+      # Java language server sends the 'language/status' notification which is
+      # not in the LSP specification.
+      'language/status',
+      # Typescript language server sends the '$/typescriptVersion'
+      # notification which is not in the LSP specification.
+      '$/typescriptVersion',
+      # Dart language server sends the '$/analyzerStatus' notification which
+      # is not in the LSP specification.
+      '$/analyzerStatus',
+      # pyright language server notifications
+      'pyright/beginProgress',
+      'pyright/reportProgress',
+      'pyright/endProgress',
+      'eslint/status',
+      'taplo/didChangeSchemaAssociation',
+      'sqlLanguageServer.finishSetup',
+      # ccls language server notifications
+      '$ccls/publishSkippedRanges',
+      '$ccls/publishSemanticHighlight',
+      # omnisharp language server notifications
+      'o#/backgrounddiagnosticstatus',
+      'o#/msbuildprojectdiagnostics',
+      'o#/projectadded',
+      'o#/projectchanged',
+      'o#/projectconfiguration',
+      'o#/projectdiagnosticstatus',
+      'o#/unresolveddependencies',
+      '@/tailwindCSS/projectInitialized'
+    ]
+
+  if lsp_notif_handlers->has_key(reply.method)
+    lsp_notif_handlers[reply.method](lspserver, reply)
+  elseif lspserver.customNotificationHandlers->has_key(reply.method)
+    lspserver.customNotificationHandlers[reply.method](lspserver, reply)
+  elseif lsp_ignored_notif_handlers->index(reply.method) == -1
+    ProcessUnsupportedNotif(lspserver, reply)
+  endif
+enddef
+
+# process the workspace/applyEdit LSP server request
+# Request: "workspace/applyEdit"
+# Param: ApplyWorkspaceEditParams
+def ProcessApplyEditReq(lspserver: dict<any>, request: dict<any>)
+  # interface ApplyWorkspaceEditParams
+  if !request->has_key('params')
+    return
+  endif
+  var workspaceEditParams: dict<any> = request.params
+  if workspaceEditParams->has_key('label')
+    util.InfoMsg($'Workspace edit {workspaceEditParams.label}')
+  endif
+  textedit.ApplyWorkspaceEdit(workspaceEditParams.edit)
+  # TODO: Need to return the proper result of the edit operation
+  lspserver.sendResponse(request, {applied: true}, {})
+enddef
+
+# process the workspace/workspaceFolders LSP server request
+# Request: "workspace/workspaceFolders"
+# Param: none
+def ProcessWorkspaceFoldersReq(lspserver: dict<any>, request: dict<any>)
+  if !lspserver->has_key('workspaceFolders')
+    lspserver.sendResponse(request, null, {})
+    return
+  endif
+  if lspserver.workspaceFolders->empty()
+    lspserver.sendResponse(request, [], {})
+  else
+    lspserver.sendResponse(request,
+	  \ lspserver.workspaceFolders->copy()->map('{name: v:val->fnamemodify(":t"), uri: util.LspFileToUri(v:val)}'),
+	  \ {})
+  endif
+enddef
+
+# process the workspace/configuration LSP server request
+# Request: "workspace/configuration"
+# Param: ConfigurationParams
+def ProcessWorkspaceConfiguration(lspserver: dict<any>, request: dict<any>)
+  var items = request.params.items
+  var response = items->map((_, item) => lspserver.workspaceConfigGet(item))
+
+  # Server expect null value if no config is given
+  if response->type() == v:t_list && response->len() == 1
+    && response[0]->type() == v:t_dict
+    && response[0] == null_dict
+    response[0] = null
+  endif
+
+  lspserver.sendResponse(request, response, {})
+enddef
+
+# process the window/workDoneProgress/create LSP server request
+# Request: "window/workDoneProgress/create"
+# Param: none
+def ProcessWorkDoneProgressCreate(lspserver: dict<any>, request: dict<any>)
+  lspserver.sendResponse(request, null, {})
+enddef
+
+# process the window/showMessageRequest LSP server request
+# Request: "window/showMessageRequest"
+# Param: ShowMessageRequestParams
+def ProcessShowMessageRequest(lspserver: dict<any>, request: dict<any>)
+  # TODO: for now 'showMessageRequest' handled same like 'showMessage'
+  # regardless 'actions'
+  ProcessShowMsgNotif(lspserver, request)
+  lspserver.sendResponse(request, null, {})
+enddef
+
+# process the client/registerCapability LSP server request
+# Request: "client/registerCapability"
+# Param: RegistrationParams
+def ProcessClientRegisterCap(lspserver: dict<any>, request: dict<any>)
+  lspserver.sendResponse(request, null, {})
+enddef
+
+# process the client/unregisterCapability LSP server request
+# Request: "client/unregisterCapability"
+# Param: UnregistrationParams
+def ProcessClientUnregisterCap(lspserver: dict<any>, request: dict<any>)
+  lspserver.sendResponse(request, null, {})
+enddef
+
+# process a request message from the server
+export def ProcessRequest(lspserver: dict<any>, request: dict<any>)
+  var lspRequestHandlers: dict<func> =
+    {
+      'client/registerCapability': ProcessClientRegisterCap,
+      'client/unregisterCapability': ProcessClientUnregisterCap,
+      'window/workDoneProgress/create': ProcessWorkDoneProgressCreate,
+      'window/showMessageRequest': ProcessShowMessageRequest,
+      'workspace/applyEdit': ProcessApplyEditReq,
+      'workspace/configuration': ProcessWorkspaceConfiguration,
+      'workspace/workspaceFolders': ProcessWorkspaceFoldersReq
+      # TODO: Handle the following requests from the server:
+      #     workspace/codeLens/refresh
+      #     workspace/diagnostic/refresh
+      #     workspace/inlayHint/refresh
+      #     workspace/inlineValue/refresh
+      #     workspace/semanticTokens/refresh
+    }
+
+  # Explicitly ignored requests
+  var lspIgnoredRequestHandlers: list<string> =
+    [
+      # Eclipse java language server sends the
+      # 'workspace/executeClientCommand' request (to reload bundles) which is
+      # not in the LSP specification.
+      'workspace/executeClientCommand',
+    ]
+
+  if lspRequestHandlers->has_key(request.method)
+    lspRequestHandlers[request.method](lspserver, request)
+  elseif lspserver.customRequestHandlers->has_key(request.method)
+    lspserver.customRequestHandlers[request.method](lspserver, request)
+  elseif lspIgnoredRequestHandlers->index(request.method) == -1
+    util.ErrMsg($'Unsupported request message received from the LSP server ({lspserver.name}), message = {request->string()}')
+  endif
+enddef
+
+# process one or more LSP server messages
+export def ProcessMessages(lspserver: dict<any>): void
+  var idx: number
+  var len: number
+  var content: string
+  var msg: dict<any>
+  var req: dict<any>
+
+  msg = lspserver.data
+  if msg->has_key('result') || msg->has_key('error')
+    # response message from the server
+    req = lspserver.requests->get(msg.id->string(), {})
+    if !req->empty()
+      # Remove the corresponding stored request message
+      lspserver.requests->remove(msg.id->string())
+
+      if msg->has_key('result')
+	lspserver.processReply(req, msg)
+      else
+	# request failed
+	var emsg: string = msg.error.message
+	emsg ..= $', code = {msg.error.code}'
+	if msg.error->has_key('data')
+	  emsg ..= $', data = {msg.error.data->string()}'
+	endif
+	util.ErrMsg($'request {req.method} failed ({emsg})')
+      endif
+    endif
+  elseif msg->has_key('id') && msg->has_key('method')
+    # request message from the server
+    lspserver.processRequest(msg)
+  elseif msg->has_key('method')
+    # notification message from the server
+    lspserver.processNotif(msg)
+  else
+    util.ErrMsg($'Unsupported message ({msg->string()})')
+  endif
+enddef
+
+# vim: tabstop=8 shiftwidth=2 softtabstop=2
diff --git a/vim/pack/downloads/opt/lsp/autoload/lsp/hover.vim b/vim/pack/downloads/opt/lsp/autoload/lsp/hover.vim
new file mode 100644
index 0000000..41e7f11
--- /dev/null
+++ b/vim/pack/downloads/opt/lsp/autoload/lsp/hover.vim
@@ -0,0 +1,137 @@
+vim9script
+
+# Functions related to displaying hover symbol information.
+
+import './util.vim'
+import './options.vim' as opt
+
+# Util used to compute the hoverText from textDocument/hover reply
+def GetHoverText(lspserver: dict<any>, hoverResult: any): list<any>
+  if hoverResult->empty()
+    return ['', '']
+  endif
+
+  # MarkupContent
+  if hoverResult.contents->type() == v:t_dict
+      && hoverResult.contents->has_key('kind')
+    if hoverResult.contents.kind == 'plaintext'
+      return [hoverResult.contents.value->split("\n"), 'text']
+    endif
+
+    if hoverResult.contents.kind == 'markdown'
+      return [hoverResult.contents.value->split("\n"), 'lspgfm']
+    endif
+
+    lspserver.errorLog(
+      $'{strftime("%m/%d/%y %T")}: Unsupported hover contents kind ({hoverResult.contents.kind})'
+    )
+    return ['', '']
+  endif
+
+  # MarkedString
+  if hoverResult.contents->type() == v:t_dict
+      && hoverResult.contents->has_key('value')
+    return [
+      [$'``` {hoverResult.contents.language}']
+        + hoverResult.contents.value->split("\n")
+        + ['```'],
+      'lspgfm'
+    ]
+  endif
+
+  # MarkedString
+  if hoverResult.contents->type() == v:t_string
+    return [hoverResult.contents->split("\n"), 'lspgfm']
+  endif
+
+  # interface MarkedString[]
+  if hoverResult.contents->type() == v:t_list
+    var hoverText: list<string> = []
+    for e in hoverResult.contents
+      if !hoverText->empty()
+        hoverText->extend(['- - -'])
+      endif
+
+      if e->type() == v:t_string
+        hoverText->extend(e->split("\n"))
+      else
+        hoverText->extend([$'``` {e.language}'])
+        hoverText->extend(e.value->split("\n"))
+        hoverText->extend(['```'])
+      endif
+    endfor
+
+    return [hoverText, 'lspgfm']
+  endif
+
+  lspserver.errorLog(
+    $'{strftime("%m/%d/%y %T")}: Unsupported hover reply ({hoverResult})'
+  )
+  return ['', '']
+enddef
+
+# Key filter function for the hover popup window.
+# Only keys to scroll the popup window are supported.
+def HoverWinFilterKey(hoverWin: number, key: string): bool
+  var keyHandled = false
+
+  if key == "\<C-E>"
+      || key == "\<C-D>"
+      || key == "\<C-F>"
+      || key == "\<PageDown>"
+      || key == "\<C-Y>"
+      || key == "\<C-U>"
+      || key == "\<C-B>"
+      || key == "\<PageUp>"
+      || key == "\<C-Home>"
+      || key == "\<C-End>"
+    # scroll the hover popup window
+    win_execute(hoverWin, $'normal! {key}')
+    keyHandled = true
+  endif
+
+  if key == "\<Esc>"
+    hoverWin->popup_close()
+    keyHandled = true
+  endif
+
+  return keyHandled
+enddef
+
+# process the 'textDocument/hover' reply from the LSP server
+# Result: Hover | null
+export def HoverReply(lspserver: dict<any>, hoverResult: any, cmdmods: string): void
+  var [hoverText, hoverKind] = GetHoverText(lspserver, hoverResult)
+
+  # Nothing to show
+  if hoverText->empty()
+    if cmdmods !~ 'silent'
+      util.WarnMsg($'No documentation found for current keyword')
+    endif
+    return
+  endif
+
+  if opt.lspOptions.hoverInPreview
+    execute $':silent! {cmdmods} pedit LspHover'
+    :wincmd P
+    :setlocal buftype=nofile
+    :setlocal bufhidden=delete
+    bufnr()->deletebufline(1, '$')
+    hoverText->append(0)
+    [1, 1]->cursor()
+    exe $'setlocal ft={hoverKind}'
+    :wincmd p
+  else
+    popup_clear()
+    var winid = hoverText->popup_atcursor({moved: 'any',
+					   close: 'click',
+					   fixed: true,
+					   maxwidth: 80,
+					   border: [0, 1, 0, 1],
+					   borderchars: [' '],
+					   filter: HoverWinFilterKey})
+    win_execute(winid, $'setlocal ft={hoverKind}')
+  endif
+enddef
+
+# vim: tabstop=8 shiftwidth=2 softtabstop=2
diff --git a/vim/pack/downloads/opt/lsp/autoload/lsp/inlayhints.vim b/vim/pack/downloads/opt/lsp/autoload/lsp/inlayhints.vim
new file mode 100644
index 0000000..a793699
--- /dev/null
+++ b/vim/pack/downloads/opt/lsp/autoload/lsp/inlayhints.vim
@@ -0,0 +1,235 @@
+vim9script
+
+# Functions for dealing with inlay hints
+
+import './util.vim'
+import './buffer.vim' as buf
+import './options.vim' as opt
+
+# Initialize the highlight group and the text property type used for
+# inlay hints.
+export def InitOnce()
+  hlset([
+    {name: 'LspInlayHintsType', default: true, linksto: 'Label'},
+    {name: 'LspInlayHintsParam', default: true, linksto: 'Conceal'}
+  ])
+  prop_type_add('LspInlayHintsType', {highlight: 'LspInlayHintsType'})
+  prop_type_add('LspInlayHintsParam', {highlight: 'LspInlayHintsParam'})
+
+  autocmd_add([{group: 'LspCmds',
+	        event: 'User',
+		pattern: 'LspOptionsChanged',
+		cmd: 'LspInlayHintsOptionsChanged()'}])
+enddef
+
+# Clear all the inlay hints text properties in the current buffer
+def InlayHintsClear(bnr: number)
+  prop_remove({type: 'LspInlayHintsType', bufnr: bnr, all: true})
+  prop_remove({type: 'LspInlayHintsParam', bufnr: bnr, all: true})
+enddef
+
+# LSP inlay hints reply message handler
+export def InlayHintsReply(lspserver: dict<any>, bnr: number, inlayHints: any)
+  if inlayHints->empty()
+    return
+  endif
+
+  InlayHintsClear(bnr)
+
+  if mode() != 'n'
+    # Update inlay hints only in normal mode
+    return
+  endif
+
+  for hint in inlayHints
+    var label = ''
+    if hint.label->type() == v:t_list
+      label = hint.label->copy()->map((_, v) => v.value)->join('')
+    else
+      label = hint.label
+    endif
+
+    # add a space before or after the label
+    var padLeft: bool = hint->get('paddingLeft', false)
+    var padRight: bool = hint->get('paddingRight', false)
+    if padLeft
+      label = $' {label}'
+    endif
+    if padRight
+      label = $'{label} '
+    endif
+
+    var kind = hint->has_key('kind') ? hint.kind->string() : '1'
+    try
+      lspserver.decodePosition(bnr, hint.position)
+      var byteIdx = util.GetLineByteFromPos(bnr, hint.position)
+      if kind == "'type'" || kind == '1'
+	prop_add(hint.position.line + 1, byteIdx + 1,
+	  {type: 'LspInlayHintsType', text: label, bufnr: bnr})
+      elseif kind == "'parameter'" || kind == '2'
+	prop_add(hint.position.line + 1, byteIdx + 1,
+	  {type: 'LspInlayHintsParam', text: label, bufnr: bnr})
+      endif
+    catch /E966\|E964/ # Invalid lnum | Invalid col
+      # Inlay hints replies arrive asynchronously and the document might have
+      # been modified in the mean time.  As the reply is stale, ignore invalid
+      # line number and column number errors.
+    endtry
+  endfor
+enddef
+
+# Timer callback to display the inlay hints.
+def InlayHintsTimerCb(lspserver: dict<any>, bnr: number, timerid: number)
+  lspserver.inlayHintsShow(bnr)
+  setbufvar(bnr, 'LspInlayHintsNeedsUpdate', false)
+enddef
+
+# Update all the inlay hints.  A timer is used to throttle the updates.
+def LspInlayHintsUpdate(bnr: number)
+  if !bnr->getbufvar('LspInlayHintsNeedsUpdate', true)
+    return
+  endif
+
+  var timerid = bnr->getbufvar('LspInlayHintsTimer', -1)
+  if timerid != -1
+    timerid->timer_stop()
+    setbufvar(bnr, 'LspInlayHintsTimer', -1)
+  endif
+
+  var lspserver: dict<any> = buf.BufLspServerGet(bnr, 'inlayHint')
+  if lspserver->empty()
+    return
+  endif
+
+  if get(g:, 'LSPTest')
+    # When running tests, update the inlay hints immediately
+    InlayHintsTimerCb(lspserver, bnr, -1)
+  else
+    timerid = timer_start(300, function('InlayHintsTimerCb', [lspserver, bnr]))
+    setbufvar(bnr, 'LspInlayHintsTimer', timerid)
+  endif
+enddef
+
+# Text is modified. Need to update the inlay hints.
+def LspInlayHintsChanged(bnr: number)
+  setbufvar(bnr, 'LspInlayHintsNeedsUpdate', true)
+enddef
+
+# Trigger an update of the inlay hints in the current buffer.
+export def LspInlayHintsUpdateNow(bnr: number)
+  setbufvar(bnr, 'LspInlayHintsNeedsUpdate', true)
+  LspInlayHintsUpdate(bnr)
+enddef
+
+# Stop updating the inlay hints.
+def LspInlayHintsUpdateStop(bnr: number)
+  var timerid = bnr->getbufvar('LspInlayHintsTimer', -1)
+  if timerid != -1
+    timerid->timer_stop()
+    setbufvar(bnr, 'LspInlayHintsTimer', -1)
+  endif
+enddef
+
+# Do buffer-local initialization for displaying inlay hints
+export def BufferInit(lspserver: dict<any>, bnr: number)
+  if !lspserver.isInlayHintProvider && !lspserver.isClangdInlayHintsProvider
+    # no support for inlay hints
+    return
+  endif
+
+  # Inlays hints are disabled
+  if !opt.lspOptions.showInlayHints
+      || !lspserver.featureEnabled('inlayHint')
+    return
+  endif
+
+  var acmds: list<dict<any>> = []
+
+  # Update the inlay hints (if needed) when the cursor is not moved for some
+  # time.
+  acmds->add({bufnr: bnr,
+		event: ['CursorHold'],
+		group: 'LspInlayHints',
+		cmd: $'LspInlayHintsUpdate({bnr})'})
+  # After the text in the current buffer is modified, the inlay hints need to
+  # be updated.
+  acmds->add({bufnr: bnr,
+		event: ['TextChanged'],
+		group: 'LspInlayHints',
+		cmd: $'LspInlayHintsChanged({bnr})'})
+  # Editing a file should trigger an inlay hint update.
+  acmds->add({bufnr: bnr,
+		event: ['BufReadPost'],
+		group: 'LspInlayHints',
+		cmd: $'LspInlayHintsUpdateNow({bnr})'})
+  # Inlay hints need not be updated if a buffer is no longer active.
+  acmds->add({bufnr: bnr,
+		event: ['BufLeave'],
+		group: 'LspInlayHints',
+		cmd: $'LspInlayHintsUpdateStop({bnr})'})
+
+  # Inlay hints maybe a bit delayed if it was a sync init lsp server.
+  if lspserver.syncInit
+    acmds->add({bufnr: bnr,
+		  event: ['User'],
+		  group: 'LspAttached',
+		  cmd: $'LspInlayHintsUpdateNow({bnr})'})
+  endif
+
+  autocmd_add(acmds)
+enddef
+
+# Track the current inlay hints enabled/disabled state.  Used when the
+# "showInlayHints" option value is changed.
+var save_showInlayHints = opt.lspOptions.showInlayHints
+
+# Enable inlay hints.  For all the buffers with an attached language server
+# that supports inlay hints, refresh the inlay hints.
+export def InlayHintsEnable()
+  opt.lspOptions.showInlayHints = true
+  for binfo in getbufinfo()
+    var lspservers: list<dict<any>> = buf.BufLspServersGet(binfo.bufnr)
+    if lspservers->empty()
+      continue
+    endif
+    for lspserver in lspservers
+      if !lspserver.ready
+	  || !lspserver.featureEnabled('inlayHint')
+	  || (!lspserver.isInlayHintProvider &&
+	      !lspserver.isClangdInlayHintsProvider)
+	continue
+      endif
+      BufferInit(lspserver, binfo.bufnr)
+      LspInlayHintsUpdateNow(binfo.bufnr)
+    endfor
+  endfor
+  save_showInlayHints = true
+enddef
+
+# Disable inlay hints for the current Vim session.  Clear the inlay hints in
+# all the buffers.
+export def InlayHintsDisable()
+  opt.lspOptions.showInlayHints = false
+  for binfo in getbufinfo()
+    var lspserver: dict<any> = buf.BufLspServerGet(binfo.bufnr, 'inlayHint')
+    if lspserver->empty()
+      continue
+    endif
+    LspInlayHintsUpdateStop(binfo.bufnr)
+    :silent! autocmd_delete([{bufnr: binfo.bufnr, group: 'LspInlayHints'}])
+    InlayHintsClear(binfo.bufnr)
+  endfor
+  save_showInlayHints = false
+enddef
+
+# Some options are changed.  If 'showInlayHints' option is changed, then
+# either enable or disable inlay hints.
+export def LspInlayHintsOptionsChanged()
+  if save_showInlayHints && !opt.lspOptions.showInlayHints
+    InlayHintsDisable()
+  elseif !save_showInlayHints && opt.lspOptions.showInlayHints
+    InlayHintsEnable()
+  endif
+enddef
+
+# vim: tabstop=8 shiftwidth=2 softtabstop=2
diff --git a/vim/pack/downloads/opt/lsp/autoload/lsp/lsp.vim b/vim/pack/downloads/opt/lsp/autoload/lsp/lsp.vim
new file mode 100644
index 0000000..507eb00
--- /dev/null
+++ b/vim/pack/downloads/opt/lsp/autoload/lsp/lsp.vim
@@ -0,0 +1,1304 @@
+vim9script
+
+# Vim9 LSP client
+#
+# The functions called by plugin/lsp.vim are in this file.
+
+# Needs Vim 9.0 and higher
+if v:version < 900
+  finish
+endif
+
+import './options.vim' as opt
+import './lspserver.vim' as lserver
+import './util.vim'
+import './buffer.vim' as buf
+import './completion.vim'
+import './textedit.vim'
+import './diag.vim'
+import './symbol.vim'
+import './outline.vim'
+import './signature.vim'
+import './codeaction.vim'
+import './inlayhints.vim'
+import './semantichighlight.vim'
+
+# LSP server information
+var LSPServers: list<dict<any>> = []
+
+# filetype to LSP server map
+var ftypeServerMap: dict<list<dict<any>>> = {}
+
+var lspInitializedOnce = false
+
+def LspInitOnce()
+  hlset([
+    {name: 'LspTextRef', default: true, linksto: 'Search'},
+    {name: 'LspReadRef', default: true, linksto: 'DiffChange'},
+    {name: 'LspWriteRef', default: true, linksto: 'DiffDelete'}
+  ])
+
+  var override = &cursorline
+      && &cursorlineopt =~ '\<line\>\|\<screenline\>\|\<both\>'
+
+  prop_type_add('LspTextRef', {highlight: 'LspTextRef', override: override})
+  prop_type_add('LspReadRef', {highlight: 'LspReadRef', override: override})
+  prop_type_add('LspWriteRef', {highlight: 'LspWriteRef', override: override})
+
+  diag.InitOnce()
+  inlayhints.InitOnce()
+  signature.InitOnce()
+  symbol.InitOnce()
+  semantichighlight.InitOnce()
+
+  lspInitializedOnce = true
+enddef
+
+# Returns the LSP servers for the a specific filetype. Based on how well there
+# score, LSP servers with the same score are being returned.
+# Returns an empty list if the servers is not found.
+def LspGetServers(bnr: number, ftype: string): list<dict<any>>
+  if !ftypeServerMap->has_key(ftype)
+    return []
+  endif
+
+  var bufDir = bnr->bufname()->fnamemodify(':p:h')
+
+  return ftypeServerMap[ftype]->filter((key, lspserver) => {
+    # Don't run the server if no path is found
+    if !lspserver.runIfSearchFiles->empty()
+      var path = util.FindNearestRootDir(bufDir, lspserver.runIfSearchFiles)
+
+      if path->empty()
+        return false
+      endif
+    endif
+
+    # Don't run the server if a path is found
+    if !lspserver.runUnlessSearchFiles->empty()
+      var path = util.FindNearestRootDir(bufDir, lspserver.runUnlessSearchFiles)
+
+      if !path->empty()
+        return false
+      endif
+    endif
+
+    # Run the server
+    return true
+  })
+enddef
+
+# Add a LSP server for a filetype
+def LspAddServer(ftype: string, lspsrv: dict<any>)
+  var lspsrvlst = ftypeServerMap->has_key(ftype) ? ftypeServerMap[ftype] : []
+  lspsrvlst->add(lspsrv)
+  ftypeServerMap[ftype] = lspsrvlst
+enddef
+
+# Enable/disable the logging of the language server protocol messages
+def ServerDebug(arg: string)
+  if ['errors', 'messages', 'off', 'on']->index(arg) == -1
+    util.ErrMsg($'Unsupported argument "{arg}"')
+    return
+  endif
+
+  var lspservers: list<dict<any>> = buf.CurbufGetServers()
+  if lspservers->empty()
+    util.WarnMsg($'No Lsp servers found for "{@%}"')
+    return
+  endif
+
+  for lspserver in lspservers
+    if arg == 'on'
+      util.ClearTraceLogs(lspserver.logfile)
+      util.ClearTraceLogs(lspserver.errfile)
+      lspserver.debug = true
+    elseif arg == 'off'
+      lspserver.debug = false
+    elseif arg == 'messages'
+      util.ServerMessagesShow(lspserver.logfile)
+    else
+      util.ServerMessagesShow(lspserver.errfile)
+    endif
+  endfor
+enddef
+
+# Show information about all the LSP servers
+export def ShowAllServers()
+  var lines = []
+  # Add filetype to server mapping information
+  lines->add('Filetype Information')
+  lines->add('====================')
+  for [ftype, lspservers] in ftypeServerMap->items()
+    for lspserver in lspservers
+      lines->add($"Filetype: '{ftype}'")
+      lines->add($"Server Name: '{lspserver.name}'")
+      lines->add($"Server Path: '{lspserver.path}'")
+      lines->add($"Status: {lspserver.running ? 'Running' : 'Not running'}")
+      lines->add('')
+    endfor
+  endfor
+
+  # Add buffer to server mapping information
+  lines->add('Buffer Information')
+  lines->add('==================')
+  for bnr in range(1, bufnr('$'))
+    var lspservers: list<dict<any>> = buf.BufLspServersGet(bnr)
+    if !lspservers->empty()
+      lines->add($"Buffer: '{bufname(bnr)}'")
+      for lspserver in lspservers
+        lines->add($"Server Path: '{lspserver.path}'")
+        lines->add($"Status: {lspserver.running ? 'Running' : 'Not running'}")
+      endfor
+      lines->add('')
+    endif
+  endfor
+
+  var wid = bufwinid('Language-Servers')
+  if wid != -1
+    wid->win_gotoid()
+    :setlocal modifiable
+    :silent! :%d _
+  else
+    :new Language-Servers
+    :setlocal buftype=nofile
+    :setlocal bufhidden=wipe
+    :setlocal noswapfile
+    :setlocal nonumber nornu
+    :setlocal fdc=0 signcolumn=no
+  endif
+  setline(1, lines)
+  :setlocal nomodified
+  :setlocal nomodifiable
+enddef
+
+# Create a new window containing the buffer "bname" or if the window is
+# already present then jump to it.
+def OpenScratchWindow(bname: string)
+  var wid = bufwinid(bname)
+  if wid != -1
+    wid->win_gotoid()
+    :setlocal modifiable
+    :silent! :%d _
+  else
+    exe $':new {bname}'
+    :setlocal buftype=nofile
+    :setlocal bufhidden=wipe
+    :setlocal noswapfile
+    :setlocal nonumber nornu
+    :setlocal fdc=0 signcolumn=no
+  endif
+enddef
+
+# Show the status of the LSP server for the current buffer
+def ShowServer(arg: string)
+  if ['status', 'capabilities', 'initializeRequest', 'messages']->index(arg) == -1
+    util.ErrMsg($'Unsupported argument "{arg}"')
+    return
+  endif
+
+  var lspservers: list<dict<any>> = buf.CurbufGetServers()
+  if lspservers->empty()
+    util.WarnMsg($'No Lsp servers found for "{@%}"')
+    return
+  endif
+
+  var windowName: string = ''
+  var lines: list<string> = []
+  if arg->empty() || arg == 'status'
+    windowName = $'LangServer-Status'
+    for lspserver in lspservers
+      if !lines->empty()
+        lines->extend(['', repeat('=', &columns), ''])
+      endif
+      var msg = $"LSP server '{lspserver.name}' is "
+      if lspserver.running
+        msg ..= 'running'
+      else
+        msg ..= 'not running'
+      endif
+      lines->add(msg)
+    endfor
+  elseif arg == 'capabilities'
+    windowName = $'LangServer-Capabilities'
+    for lspserver in lspservers
+      if !lines->empty()
+        lines->extend(['', repeat('=', &columns), ''])
+      endif
+      lines->extend(lspserver.getCapabilities())
+    endfor
+  elseif arg == 'initializeRequest'
+    windowName = $'LangServer-InitializeRequest'
+    for lspserver in lspservers
+      if !lines->empty()
+        lines->extend(['', repeat('=', &columns), ''])
+      endif
+      lines->extend(lspserver.getInitializeRequest())
+    endfor
+  elseif arg == 'messages'
+    windowName = $'LangServer-Messages'
+    for lspserver in lspservers
+      if !lines->empty()
+        lines->extend(['', repeat('=', &columns), ''])
+      endif
+      lines->extend(lspserver.getMessages())
+    endfor
+  else
+    util.ErrMsg($'Unsupported argument "{arg}"')
+    return
+  endif
+
+  if lines->len() > 1
+    OpenScratchWindow(windowName)
+    setline(1, lines)
+    :setlocal nomodified
+    :setlocal nomodifiable
+  else
+    util.InfoMsg(lines[0])
+  endif
+enddef
+
+# Get LSP server running status for filetype "ftype"
+# Return true if running, or false if not found or not running
+export def ServerRunning(ftype: string): bool
+  if ftypeServerMap->has_key(ftype)
+    var lspservers = ftypeServerMap[ftype]
+    for lspserver in lspservers
+      if lspserver.running
+        return true
+      endif
+    endfor
+  endif
+
+  return false
+enddef
+
+# Go to a definition using "textDocument/definition" LSP request
+export def GotoDefinition(peek: bool, cmdmods: string, count: number)
+  var lspserver: dict<any> = buf.CurbufGetServerChecked('definition')
+  if lspserver->empty()
+    return
+  endif
+
+  lspserver.gotoDefinition(peek, cmdmods, count)
+enddef
+
+# Go to a declaration using "textDocument/declaration" LSP request
+export def GotoDeclaration(peek: bool, cmdmods: string, count: number)
+  var lspserver: dict<any> = buf.CurbufGetServerChecked('declaration')
+  if lspserver->empty()
+    return
+  endif
+
+  lspserver.gotoDeclaration(peek, cmdmods, count)
+enddef
+
+# Go to a type definition using "textDocument/typeDefinition" LSP request
+export def GotoTypedef(peek: bool, cmdmods: string, count: number)
+  var lspserver: dict<any> = buf.CurbufGetServerChecked('typeDefinition')
+  if lspserver->empty()
+    return
+  endif
+
+  lspserver.gotoTypeDef(peek, cmdmods, count)
+enddef
+
+# Go to a implementation using "textDocument/implementation" LSP request
+export def GotoImplementation(peek: bool, cmdmods: string, count: number)
+  var lspserver: dict<any> = buf.CurbufGetServerChecked('implementation')
+  if lspserver->empty()
+    return
+  endif
+
+  lspserver.gotoImplementation(peek, cmdmods, count)
+enddef
+
+# Switch source header using "textDocument/switchSourceHeader" LSP request
+# (Clangd specifc extension)
+export def SwitchSourceHeader()
+  var lspserver: dict<any> = buf.CurbufGetServerChecked()
+  if lspserver->empty()
+    return
+  endif
+
+  lspserver.switchSourceHeader()
+enddef
+
+# A buffer is saved. Send the "textDocument/didSave" LSP notification
+def LspSavedFile(bnr: number)
+  var lspservers: list<dict<any>> = buf.BufLspServersGet(bnr)->filter(
+    (key, lspsrv) => !lspsrv->empty() && lspsrv.running
+  )
+
+  if lspservers->empty()
+    return
+  endif
+
+  for lspserver in lspservers
+    lspserver.didSaveFile(bnr)
+  endfor
+enddef
+
+# Called after leaving insert mode. Used to process diag messages (if any)
+def LspLeftInsertMode(bnr: number)
+  var updatePending: bool = bnr->getbufvar('LspDiagsUpdatePending', false)
+  if !updatePending
+    return
+  endif
+  setbufvar(bnr, 'LspDiagsUpdatePending', false)
+
+  diag.ProcessNewDiags(bnr)
+enddef
+
+# Add buffer-local autocmds when attaching a LSP server to a buffer
+def AddBufLocalAutocmds(lspserver: dict<any>, bnr: number): void
+  var acmds: list<dict<any>> = []
+
+  # file saved notification handler
+  acmds->add({bufnr: bnr,
+	      event: 'BufWritePost',
+	      group: 'LSPBufferAutocmds',
+	      cmd: $'LspSavedFile({bnr})'})
+
+  # Update the diagnostics when insert mode is stopped
+  acmds->add({bufnr: bnr,
+	      event: 'InsertLeave',
+	      group: 'LSPBufferAutocmds',
+	      cmd: $'LspLeftInsertMode({bnr})'})
+
+  # Auto highlight all the occurrences of the current keyword
+  if opt.lspOptions.autoHighlight &&
+			lspserver.isDocumentHighlightProvider
+    acmds->add({bufnr: bnr,
+		event: 'CursorMoved',
+		group: 'LSPBufferAutocmds',
+		cmd: $'call LspDocHighlightClear({bnr}) | call LspDocHighlight({bnr}, "silent")'})
+  endif
+
+  autocmd_add(acmds)
+enddef
+
+# The LSP server with ID "lspserverId" is ready, initialize the LSP features
+# for buffer "bnr".
+def BufferInit(lspserverId: number, bnr: number): void
+  var lspserver = buf.BufLspServerGetById(bnr, lspserverId)
+  if lspserver->empty() || !lspserver.running
+    return
+  endif
+
+  var ftype: string = bnr->getbufvar('&filetype')
+  lspserver.textdocDidOpen(bnr, ftype)
+
+  # add a listener to track changes to this buffer
+  listener_add((_bnr: number, start: number, end: number, added: number, changes: list<dict<number>>) => {
+    lspserver.textdocDidChange(bnr, start, end, added, changes)
+  }, bnr)
+
+  AddBufLocalAutocmds(lspserver, bnr)
+
+  diag.BufferInit(lspserver, bnr)
+
+  var allServersReady = true
+  var lspservers: list<dict<any>> = buf.BufLspServersGet(bnr)
+  for lspsrv in lspservers
+    if !lspsrv.ready
+      allServersReady = false
+      break
+    endif
+  endfor
+
+  if allServersReady
+    for lspsrv in lspservers
+      # It's only possible to initialize the features when the server
+      # capabilities of all the registered language servers for this file type
+      # are known.
+      var completionServer = buf.BufLspServerGet(bnr, 'completion')
+      if !completionServer->empty() && lspsrv.id == completionServer.id
+        completion.BufferInit(lspsrv, bnr, ftype)
+      endif
+
+      var signatureServer = buf.BufLspServerGet(bnr, 'signatureHelp')
+      if !signatureServer->empty() && lspsrv.id == signatureServer.id
+	signature.BufferInit(lspsrv)
+      endif
+
+      var inlayHintServer = buf.BufLspServerGet(bnr, 'inlayHint')
+      if !inlayHintServer->empty() && lspsrv.id == inlayHintServer.id
+	inlayhints.BufferInit(lspsrv, bnr)
+      endif
+
+      var semanticServer = buf.BufLspServerGet(bnr, 'semanticTokens')
+      if !semanticServer->empty() && lspsrv.id == semanticServer.id
+	semantichighlight.BufferInit(lspserver, bnr)
+      endif
+    endfor
+
+    if exists('#User#LspAttached')
+      doautocmd <nomodeline> User LspAttached
+    endif
+  endif
+enddef
+
+# A new buffer is opened. If LSP is supported for this buffer, then add it
+export def AddFile(bnr: number): void
+  if buf.BufHasLspServer(bnr)
+    # LSP server for this buffer is already initialized and running
+    return
+  endif
+
+  # Skip remote files
+  if util.LspUriRemote(bnr->bufname()->fnamemodify(':p'))
+    return
+  endif
+
+  var ftype: string = bnr->getbufvar('&filetype')
+  if ftype->empty()
+    return
+  endif
+  var lspservers: list<dict<any>> = LspGetServers(bnr, ftype)
+  if lspservers->empty()
+    return
+  endif
+  for lspserver in lspservers
+    if !lspserver.running
+      if !lspInitializedOnce
+        LspInitOnce()
+      endif
+      lspserver.startServer(bnr)
+    endif
+    buf.BufLspServerSet(bnr, lspserver)
+
+    if lspserver.ready
+      BufferInit(lspserver.id, bnr)
+    else
+      augroup LSPBufferAutocmds
+        exe $'autocmd User LspServerReady_{lspserver.id} ++once BufferInit({lspserver.id}, {bnr})'
+      augroup END
+    endif
+  endfor
+enddef
+
+# Notify LSP server to remove a file
+export def RemoveFile(bnr: number): void
+  var lspservers: list<dict<any>> = buf.BufLspServersGet(bnr)
+  for lspserver in lspservers->copy()
+    if lspserver->empty()
+      continue
+    endif
+    if lspserver.running
+      lspserver.textdocDidClose(bnr)
+    endif
+    diag.DiagRemoveFile(bnr)
+    buf.BufLspServerRemove(bnr, lspserver)
+  endfor
+enddef
+
+# Buffer 'bnr' is loaded in a window, send the latest buffer contents to the
+# language servers.
+export def BufferLoadedInWin(bnr: number)
+  var lspservers: list<dict<any>> = buf.BufLspServersGet(bnr)
+  if lspservers->empty()
+    # No language servers for this buffer
+    return
+  endif
+  for lspserver in lspservers
+    if !lspserver->empty() && lspserver.ready
+      lspserver.textdocDidChange(bnr, 0, 0, 0, [])
+    endif
+  endfor
+  # Refresh the displayed diags visuals
+  if opt.lspOptions.autoHighlightDiags
+    diag.DiagsRefresh(bnr)
+  endif
+
+  completion.BufferLoadedInWin(bnr)
+
+  # Refresh the semantic highlights
+  if opt.lspOptions.semanticHighlight
+    var semanticServer = buf.BufLspServerGet(bnr, 'semanticTokens')
+    if !semanticServer->empty()
+      semanticServer.semanticHighlightUpdate(bnr)
+    endif
+  endif
+enddef
+
+# Stop all the LSP servers
+export def StopAllServers()
+  for lspserver in LSPServers
+    if lspserver.running
+      lspserver.stopServer()
+    endif
+  endfor
+enddef
+
+# Add all the buffers with 'filetype' set to "ftype" to the language server.
+def AddBuffersToLsp(ftype: string)
+  # Add all the buffers with the same file type as the current buffer
+  for binfo in getbufinfo({bufloaded: 1})
+    if binfo.bufnr->getbufvar('&filetype') == ftype
+      AddFile(binfo.bufnr)
+    endif
+  endfor
+enddef
+
+# Restart the LSP server for the current buffer
+def RestartServer()
+  var lspservers: list<dict<any>> = buf.CurbufGetServers()
+  if lspservers->empty()
+    util.WarnMsg($'No Lsp servers found for "{@%}"')
+    return
+  endif
+
+  # Remove all the buffers with the same file type as the current buffer
+  var ftype: string = &filetype
+  for binfo in getbufinfo()
+    if binfo.bufnr->getbufvar('&filetype') == ftype
+      RemoveFile(binfo.bufnr)
+    endif
+  endfor
+
+  for lspserver in lspservers
+    # Stop the server (if running)
+    if lspserver.running
+      lspserver.stopServer()
+    endif
+
+    # Start the server again
+    lspserver.startServer(bufnr())
+  endfor
+
+  AddBuffersToLsp(ftype)
+enddef
+
+# Add the LSP server for files with 'filetype' as "ftype".
+def AddServerForFiltype(lspserver: dict<any>, ftype: string, omnicompl: bool)
+  LspAddServer(ftype, lspserver)
+  completion.OmniComplSet(ftype, omnicompl)
+
+  # If a buffer of this file type is already present, then send it to the LSP
+  # server now.
+  AddBuffersToLsp(ftype)
+enddef
+
+# Register a LSP server for one or more file types
+export def AddServer(serverList: list<dict<any>>)
+  for server in serverList
+    if !server->has_key('filetype') || !server->has_key('path')
+      util.ErrMsg('LSP server information is missing filetype or path')
+      continue
+    endif
+    # Enable omni-completion by default
+    var omnicompl_def: bool = false
+    if opt.lspOptions.omniComplete == true
+	|| (opt.lspOptions.omniComplete == null
+	    && !opt.lspOptions.autoComplete)
+      omnicompl_def = true
+    endif
+    server.omnicompl = server->get('omnicompl', omnicompl_def)
+
+    if !server.path->executable()
+      if !opt.lspOptions.ignoreMissingServer
+        util.ErrMsg($'LSP server {server.path} is not found')
+      endif
+      continue
+    endif
+    if server->has_key('args')
+      if server.args->type() != v:t_list
+        util.ErrMsg($'Arguments for LSP server {server.args} is not a List')
+        continue
+      endif
+    else
+      server.args = []
+    endif
+
+    if !server->has_key('initializationOptions')
+	|| server.initializationOptions->type() != v:t_dict
+      server.initializationOptions = {}
+    endif
+
+    if !server->has_key('forceOffsetEncoding')
+	|| server.forceOffsetEncoding->type() != v:t_string
+	|| (server.forceOffsetEncoding != 'utf-8'
+	    && server.forceOffsetEncoding != 'utf-16'
+	    && server.forceOffsetEncoding != 'utf-32')
+      server.forceOffsetEncoding = ''
+    endif
+
+    if !server->has_key('customNotificationHandlers')
+	|| server.customNotificationHandlers->type() != v:t_dict
+      server.customNotificationHandlers = {}
+    endif
+
+    if server->has_key('processDiagHandler')
+      if server.processDiagHandler->type() != v:t_func
+        util.ErrMsg($'Setting of processDiagHandler {server.processDiagHandler} is not a Funcref nor lambda')
+        continue
+      endif
+    else
+      server.processDiagHandler = null_function
+    endif
+
+    if !server->has_key('customRequestHandlers')
+	|| server.customRequestHandlers->type() != v:t_dict
+      server.customRequestHandlers = {}
+    endif
+
+    if !server->has_key('features') || server.features->type() != v:t_dict
+      server.features = {}
+    endif
+
+    if server.omnicompl->type() != v:t_bool
+      util.ErrMsg($'Setting of omnicompl {server.omnicompl} is not a Boolean')
+      continue
+    endif
+
+    if !server->has_key('syncInit')
+      server.syncInit = false
+    endif
+
+    if !server->has_key('name') || server.name->type() != v:t_string
+	|| server.name->empty()
+      # Use the executable name (without the extension) as the language server
+      # name.
+      server.name = server.path->fnamemodify(':t:r')
+    endif
+
+    if !server->has_key('debug') || server.debug->type() != v:t_bool
+      server.debug = false
+    endif
+
+    if !server->has_key('traceLevel')
+	|| server->type() != v:t_string
+	|| (server.traceLevel != 'off' && server.traceLevel != 'debug'
+	    && server.traceLevel != 'verbose')
+      server.traceLevel = 'off'
+    endif
+
+    if !server->has_key('workspaceConfig')
+	|| server.workspaceConfig->type() != v:t_dict
+      server.workspaceConfig = {}
+    endif
+
+    if !server->has_key('rootSearch') || server.rootSearch->type() != v:t_list
+      server.rootSearch = []
+    endif
+
+    if !server->has_key('runIfSearch') ||
+	server.runIfSearch->type() != v:t_list
+      server.runIfSearch = []
+    endif
+
+    if !server->has_key('runUnlessSearch') ||
+	server.runUnlessSearch->type() != v:t_list
+      server.runUnlessSearch = []
+    endif
+
+    var lspserver: dict<any> = lserver.NewLspServer(server)
+
+    var ftypes = server.filetype
+    if ftypes->type() == v:t_string
+      AddServerForFiltype(lspserver, ftypes, server.omnicompl)
+    elseif ftypes->type() == v:t_list
+      for ftype in ftypes
+	AddServerForFiltype(lspserver, ftype, server.omnicompl)
+      endfor
+    else
+      util.ErrMsg($'Unsupported file type information "{ftypes->string()}" in LSP server registration')
+      continue
+    endif
+  endfor
+enddef
+
+# The LSP server is considered ready when the server capabilities are
+# received ("initialize" LSP reply message)
+export def ServerReady(): bool
+  var fname: string = @%
+  if fname->empty()
+    return false
+  endif
+
+  var lspservers: list<dict<any>> = buf.CurbufGetServers()
+  if lspservers->empty()
+    return false
+  endif
+
+  for lspserver in lspservers
+    if !lspserver.ready
+      return false
+    endif
+  endfor
+
+  return true
+enddef
+
+# set the LSP server trace level for the current buffer
+# Params: SetTraceParams
+def ServerTraceSet(traceVal: string)
+  if ['off', 'messages', 'verbose']->index(traceVal) == -1
+    util.ErrMsg($'Unsupported argument "{traceVal}"')
+    return
+  endif
+
+  var lspservers: list<dict<any>> = buf.CurbufGetServers()
+  if lspservers->empty()
+    util.WarnMsg($'No Lsp servers found for "{@%}"')
+    return
+  endif
+
+  for lspserver in lspservers
+    lspserver.setTrace(traceVal)
+  endfor
+enddef
+
+# Display the diagnostic messages from the LSP server for the current buffer
+# in a quickfix list
+export def ShowDiagnostics(): void
+  diag.ShowAllDiags()
+enddef
+
+# Show the diagnostic message for the current line
+export def LspShowCurrentDiag(atPos: bool)
+  diag.ShowCurrentDiag(atPos)
+enddef
+
+# get the count of diagnostics in the current buffer
+export def ErrorCount(): dict<number>
+  var res = {Error: 0, Warn: 0, Info: 0, Hint: 0}
+  var fname: string = @%
+  if fname->empty()
+    return res
+  endif
+
+  return diag.DiagsGetErrorCount(bufnr())
+enddef
+
+# jump to the next/previous/first diagnostic message in the current buffer
+export def JumpToDiag(which: string, count: number = 0): void
+  diag.LspDiagsJump(which, count)
+enddef
+
+# Display the hover message from the LSP server for the current cursor
+# location
+export def Hover(cmdmods: string)
+  var lspserver: dict<any> = buf.CurbufGetServerChecked('hover')
+  if lspserver->empty()
+    return
+  endif
+
+  lspserver.hover(cmdmods)
+enddef
+
+# Enable or disable inlay hints
+export def InlayHints(ctl: string)
+  if ctl == 'enable'
+    inlayhints.InlayHintsEnable()
+  elseif ctl == 'disable'
+    inlayhints.InlayHintsDisable()
+  else
+    util.ErrMsg($'LspInlayHints - Unsupported argument "{ctl}"')
+  endif
+enddef
+
+# Command-line completion for the ":LspInlayHints" command
+export def LspInlayHintsComplete(arglead: string, cmdline: string, cursorPos: number): list<string>
+  var l = ['enable', 'disable']
+  return filter(l, (_, val) => val =~ $'^{arglead}')
+enddef
+
+# show symbol references
+export def ShowReferences(peek: bool)
+  var lspserver: dict<any> = buf.CurbufGetServerChecked('references')
+  if lspserver->empty()
+    return
+  endif
+
+  lspserver.showReferences(peek)
+enddef
+
+# highlight all the places where a symbol is referenced
+def g:LspDocHighlight(bnr: number = bufnr(), cmdmods: string = '')
+  var lspserver: dict<any> = buf.CurbufGetServerChecked('documentHighlight')
+  if lspserver->empty()
+    return
+  endif
+
+  lspserver.docHighlight(bnr, cmdmods)
+enddef
+
+# clear the symbol reference highlight
+def g:LspDocHighlightClear(bnr: number = bufnr())
+  var lspserver: dict<any> = buf.CurbufGetServerChecked('documentHighlight')
+  if lspserver->empty()
+    return
+  endif
+
+  var propNames = ['LspTextRef', 'LspReadRef', 'LspWriteRef']
+  if has('patch-9.0.0233')
+    prop_remove({types: propNames, bufnr: bnr, all: true})
+  else
+    for propName in propNames
+      prop_remove({type: propName, bufnr: bnr, all: true})
+    endfor
+  endif
+enddef
+
+def g:LspRequestDocSymbols()
+  if outline.SkipOutlineRefresh()
+    return
+  endif
+
+  var fname: string = @%
+  if fname->empty()
+    return
+  endif
+
+  var lspserver: dict<any> = buf.CurbufGetServer('documentSymbol')
+  if lspserver->empty() || !lspserver.running || !lspserver.ready
+    return
+  endif
+
+  lspserver.getDocSymbols(fname, true)
+enddef
+
+# open a window and display all the symbols in a file (outline)
+export def Outline(cmdmods: string, winsize: number)
+  var fname: string = @%
+  if fname->empty()
+    return
+  endif
+
+  var lspserver: dict<any> = buf.CurbufGetServerChecked('documentSymbol')
+  if lspserver->empty() || !lspserver.running || !lspserver.ready
+    return
+  endif
+
+  outline.OpenOutlineWindow(cmdmods, winsize)
+  g:LspRequestDocSymbols()
+enddef
+
+# show all the symbols in a file in a popup menu
+export def ShowDocSymbols()
+  var fname: string = @%
+  if fname->empty()
+    return
+  endif
+
+  var lspserver: dict<any> = buf.CurbufGetServerChecked('documentSymbol')
+  if lspserver->empty() || !lspserver.running || !lspserver.ready
+    return
+  endif
+
+  lspserver.getDocSymbols(fname, false)
+enddef
+
+# Format the entire file
+export def TextDocFormat(range_args: number, line1: number, line2: number)
+  if !&modifiable
+    util.ErrMsg('Current file is not a modifiable file')
+    return
+  endif
+
+  var lspserver: dict<any> = buf.CurbufGetServerChecked('documentFormatting')
+  if lspserver->empty()
+    return
+  endif
+
+  var fname: string = @%
+  if range_args > 0
+    lspserver.textDocFormat(fname, true, line1, line2)
+  else
+    lspserver.textDocFormat(fname, false, 0, 0)
+  endif
+enddef
+
+# TODO: Add support for textDocument.onTypeFormatting?
+# Will this slow down Vim?
+
+# Display all the locations where the current symbol is called from.
+# Uses LSP "callHierarchy/incomingCalls" request
+export def IncomingCalls()
+  var lspserver: dict<any> = buf.CurbufGetServerChecked('callHierarchy')
+  if lspserver->empty()
+    return
+  endif
+
+  lspserver.incomingCalls(@%)
+enddef
+
+# Display all the symbols used by the current symbol.
+# Uses LSP "callHierarchy/outgoingCalls" request
+export def OutgoingCalls()
+  var lspserver: dict<any> = buf.CurbufGetServerChecked('callHierarchy')
+  if lspserver->empty()
+    return
+  endif
+
+  lspserver.outgoingCalls(@%)
+enddef
+
+# Display the type hierarchy for the current symbol.  Direction is 0 for
+# sub types and 1 for super types.
+export def TypeHierarchy(direction: number)
+  var lspserver: dict<any> = buf.CurbufGetServerChecked('typeHierarchy')
+  if lspserver->empty()
+    return
+  endif
+
+  lspserver.typeHierarchy(direction)
+enddef
+
+# Rename a symbol
+# Uses LSP "textDocument/rename" request
+export def Rename(a_newName: string)
+  var lspserver: dict<any> = buf.CurbufGetServerChecked('rename')
+  if lspserver->empty()
+    return
+  endif
+
+  var newName: string = a_newName
+  if newName->empty()
+    var sym: string = expand('<cword>')
+    newName = input($"Rename symbol '{sym}' to: ", sym)
+    if newName->empty()
+      return
+    endif
+
+    # clear the input prompt
+    :echo "\r"
+  endif
+
+  lspserver.renameSymbol(newName)
+enddef
+
+# Perform a code action
+# Uses LSP "textDocument/codeAction" request
+export def CodeAction(line1: number, line2: number, query: string)
+  var lspserver: dict<any> = buf.CurbufGetServerChecked('codeAction')
+  if lspserver->empty()
+    return
+  endif
+
+  var fname: string = @%
+  lspserver.codeAction(fname, line1, line2, query)
+enddef
+
+# Code lens
+# Uses LSP "textDocument/codeLens" request
+export def CodeLens()
+  var lspserver: dict<any> = buf.CurbufGetServerChecked('codeLens')
+  if lspserver->empty()
+    return
+  endif
+
+  lspserver.codeLens(@%)
+enddef
+
+# Perform a workspace wide symbol lookup
+# Uses LSP "workspace/symbol" request
+export def SymbolSearch(queryArg: string, cmdmods: string)
+  var lspserver: dict<any> = buf.CurbufGetServerChecked('workspaceSymbol')
+  if lspserver->empty()
+    return
+  endif
+
+  var query: string = queryArg
+  if query->empty()
+    query = input('Lookup symbol: ', expand('<cword>'))
+    if query->empty()
+      return
+    endif
+  endif
+  :redraw!
+
+  lspserver.workspaceQuery(query, true, cmdmods)
+enddef
+
+# Display the list of workspace folders
+export def ListWorkspaceFolders()
+  var lspservers: list<dict<any>> = buf.CurbufGetServers()
+  for lspserver in lspservers
+    util.InfoMsg($'Workspace Folders: "{lspserver.name}" {lspserver.workspaceFolders->string()}')
+  endfor
+enddef
+
+# Add a workspace folder. Default is to use the current folder.
+export def AddWorkspaceFolder(dirArg: string)
+  var dirName: string = dirArg
+  if dirName->empty()
+    dirName = input('Add Workspace Folder: ', getcwd(), 'dir')
+    if dirName->empty()
+      return
+    endif
+  endif
+  :redraw!
+  if !dirName->isdirectory()
+    util.ErrMsg($'{dirName} is not a directory')
+    return
+  endif
+
+  var lspservers: list<dict<any>> = buf.CurbufGetServers()
+
+  for lspserver in lspservers
+    lspserver.addWorkspaceFolder(dirName)
+  endfor
+enddef
+
+# Remove a workspace folder. Default is to use the current folder.
+export def RemoveWorkspaceFolder(dirArg: string)
+  var dirName: string = dirArg
+  if dirName->empty()
+    dirName = input('Remove Workspace Folder: ', getcwd(), 'dir')
+    if dirName->empty()
+      return
+    endif
+  endif
+  :redraw!
+  if !dirName->isdirectory()
+    util.ErrMsg($'{dirName} is not a directory')
+    return
+  endif
+
+  var lspservers: list<dict<any>> = buf.CurbufGetServers()
+  for lspserver in lspservers
+    lspserver.removeWorkspaceFolder(dirName)
+  endfor
+enddef
+
+# expand the previous selection or start a new selection
+export def SelectionExpand()
+  var lspserver: dict<any> = buf.CurbufGetServerChecked('selectionRange')
+  if lspserver->empty()
+    return
+  endif
+
+  lspserver.selectionExpand()
+enddef
+
+# shrink the previous selection or start a new selection
+export def SelectionShrink()
+  var lspserver: dict<any> = buf.CurbufGetServerChecked('selectionRange')
+  if lspserver->empty()
+    return
+  endif
+
+  lspserver.selectionShrink()
+enddef
+
+# fold the entire document
+export def FoldDocument()
+  var lspserver: dict<any> = buf.CurbufGetServerChecked('foldingRange')
+  if lspserver->empty()
+    return
+  endif
+
+  if &foldmethod != 'manual'
+    util.ErrMsg("Only works when 'foldmethod' is 'manual'")
+    return
+  endif
+
+  var fname: string = @%
+  lspserver.foldRange(fname)
+enddef
+
+# Enable diagnostic highlighting for all the buffers
+export def DiagHighlightEnable()
+  diag.DiagsHighlightEnable()
+enddef
+
+# Disable diagnostic highlighting for all the buffers
+export def DiagHighlightDisable()
+  diag.DiagsHighlightDisable()
+enddef
+
+# Function to use with the 'tagfunc' option.
+export def TagFunc(pat: string, flags: string, info: dict<any>): any
+  var lspserver: dict<any> = buf.CurbufGetServerChecked('definition')
+  if lspserver->empty()
+    return v:null
+  endif
+
+  return lspserver.tagFunc(pat, flags, info)
+enddef
+
+# Function to use with the 'formatexpr' option.
+export def FormatExpr(): number
+  var lspserver: dict<any> = buf.CurbufGetServerChecked('documentFormatting')
+  if lspserver->empty()
+    return 1
+  endif
+
+  lspserver.textDocFormat(@%, true, v:lnum, v:lnum + v:count - 1)
+  return 0
+enddef
+
+export def RegisterCmdHandler(cmd: string, Handler: func)
+  codeaction.RegisterCmdHandler(cmd, Handler)
+enddef
+
+# Command-line completion for the ":LspServer <cmd>" and ":LspDiag <cmd>" sub
+# commands
+def LspSubCmdComplete(cmds: list<string>, arglead: string, cmdline: string, cursorPos: number): list<string>
+  var wordBegin = cmdline->match('\s\+\zs\S', cursorPos)
+  if wordBegin == -1
+    return cmds
+  endif
+
+  # Make sure there are no additional sub-commands
+  var wordEnd = cmdline->stridx(' ', wordBegin)
+  if wordEnd == -1
+    return cmds->filter((_, val) => val =~ $'^{arglead}')
+  endif
+
+  return []
+enddef
+
+# Command-line completion for the ":LspDiag highlight" command
+def LspDiagHighlightComplete(arglead: string, cmdline: string, cursorPos: number): list<string>
+  return LspSubCmdComplete(['enable', 'disable'], arglead, cmdline, cursorPos)
+enddef
+
+# Command-line completion for the ":LspDiag" command
+export def LspDiagComplete(arglead: string, cmdline: string, cursorPos: number): list<string>
+  var wordBegin = -1
+  var wordEnd = -1
+  var l = ['first', 'current', 'here', 'highlight', 'last', 'next', 'nextWrap',
+           'prev', 'prevWrap', 'show']
+
+  # Skip the command name
+  var i = cmdline->stridx(' ', 0)
+  wordBegin = cmdline->match('\s\+\zs\S', i)
+  if wordBegin == -1
+    return l
+  endif
+
+  wordEnd = cmdline->stridx(' ', wordBegin)
+  if wordEnd == -1
+    return filter(l, (_, val) => val =~ $'^{arglead}')
+  endif
+
+  var cmd = cmdline->strpart(wordBegin, wordEnd - wordBegin)
+  if cmd == 'highlight'
+    return LspDiagHighlightComplete(arglead, cmdline, wordEnd)
+  endif
+
+  return []
+enddef
+
+# ":LspDiag" command handler
+export def LspDiagCmd(args: string, cmdCount: number, force: bool)
+  if args->stridx('highlight') == 0
+    if args[9] == ' '
+      var subcmd = args[10 : ]->trim()
+      if subcmd == 'enable'
+	diag.DiagsHighlightEnable()
+      elseif subcmd == 'disable'
+	diag.DiagsHighlightDisable()
+      else
+	util.ErrMsg($':LspDiag highlight - Unsupported argument "{subcmd}"')
+      endif
+    else
+      util.ErrMsg('Argument required for ":LspDiag highlight"')
+    endif
+  elseif args == 'first'
+    diag.LspDiagsJump('first', 0)
+  elseif args == 'current'
+    LspShowCurrentDiag(force)
+  elseif args == 'here'
+    diag.LspDiagsJump('here', 0)
+  elseif args == 'last'
+    diag.LspDiagsJump('last', 0)
+  elseif args == 'next'
+    diag.LspDiagsJump('next', cmdCount)
+  elseif args == 'nextWrap'
+    diag.LspDiagsJump('nextWrap', cmdCount)
+  elseif args == 'prev'
+    diag.LspDiagsJump('prev', cmdCount)
+  elseif args == 'prevWrap'
+    diag.LspDiagsJump('prevWrap', cmdCount)
+  elseif args == 'show'
+    ShowDiagnostics()
+  else
+    util.ErrMsg($':LspDiag - Unsupported argument "{args}"')
+  endif
+enddef
+
+# Command-line completion for the ":LspServer debug" command
+def LspServerDebugComplete(arglead: string, cmdline: string, cursorPos: number): list<string>
+  return LspSubCmdComplete(['errors', 'messages', 'off', 'on'], arglead,
+			   cmdline, cursorPos)
+enddef
+
+# Command-line completion for the ":LspServer show" command
+def LspServerShowComplete(arglead: string, cmdline: string, cursorPos: number): list<string>
+  return LspSubCmdComplete(['capabilities', 'initializeRequest', 'messages',
+			    'status'], arglead, cmdline, cursorPos)
+enddef
+
+# Command-line completion for the ":LspServer trace" command
+def LspServerTraceComplete(arglead: string, cmdline: string, cursorPos: number): list<string>
+  return LspSubCmdComplete(['messages', 'off', 'verbose'], arglead, cmdline,
+			   cursorPos)
+enddef
+
+# Command-line completion for the ":LspServer" command
+export def LspServerComplete(arglead: string, cmdline: string, cursorPos: number): list<string>
+  var wordBegin = -1
+  var wordEnd = -1
+  var l = ['debug', 'restart', 'show', 'trace']
+
+  # Skip the command name
+  var i = cmdline->stridx(' ', 0)
+  wordBegin = cmdline->match('\s\+\zs\S', i)
+  if wordBegin == -1
+    return l
+  endif
+
+  wordEnd = cmdline->stridx(' ', wordBegin)
+  if wordEnd == -1
+    return filter(l, (_, val) => val =~ $'^{arglead}')
+  endif
+
+  var cmd = cmdline->strpart(wordBegin, wordEnd - wordBegin)
+  if cmd == 'debug'
+    return LspServerDebugComplete(arglead, cmdline, wordEnd)
+  elseif cmd == 'restart'
+  elseif cmd == 'show'
+    return LspServerShowComplete(arglead, cmdline, wordEnd)
+  elseif cmd == 'trace'
+    return LspServerTraceComplete(arglead, cmdline, wordEnd)
+  endif
+
+  return []
+enddef
+
+# ":LspServer" command handler
+export def LspServerCmd(args: string)
+  if args->stridx('debug') == 0
+    if args[5] == ' '
+      var subcmd = args[6 : ]->trim()
+      ServerDebug(subcmd)
+    else
+      util.ErrMsg('Argument required for ":LspServer debug"')
+    endif
+  elseif args == 'restart'
+    RestartServer()
+  elseif args->stridx('show') == 0
+    if args[4] == ' '
+      var subcmd = args[5 : ]->trim()
+      ShowServer(subcmd)
+    else
+      util.ErrMsg('Argument required for ":LspServer show"')
+    endif
+  elseif args->stridx('trace') == 0
+    if args[5] == ' '
+      var subcmd = args[6 : ]->trim()
+      ServerTraceSet(subcmd)
+    else
+      util.ErrMsg('Argument required for ":LspServer trace"')
+    endif
+  else
+    util.ErrMsg($'LspServer - Unsupported argument "{args}"')
+  endif
+enddef
+
+# vim: tabstop=8 shiftwidth=2 softtabstop=2 noexpandtab
diff --git a/vim/pack/downloads/opt/lsp/autoload/lsp/lspserver.vim b/vim/pack/downloads/opt/lsp/autoload/lsp/lspserver.vim
new file mode 100644
index 0000000..bfbdd77
--- /dev/null
+++ b/vim/pack/downloads/opt/lsp/autoload/lsp/lspserver.vim
@@ -0,0 +1,1982 @@
+vim9script
+
+# LSP server functions
+#
+# The functions to send request messages to the language server are in this
+# file.
+#
+# Refer to https://microsoft.github.io/language-server-protocol/specification
+# for the Language Server Protocol (LSP) specificaiton.
+
+import './options.vim' as opt
+import './handlers.vim'
+import './util.vim'
+import './capabilities.vim'
+import './offset.vim'
+import './diag.vim'
+import './selection.vim'
+import './symbol.vim'
+import './textedit.vim'
+import './completion.vim'
+import './hover.vim'
+import './signature.vim'
+import './codeaction.vim'
+import './codelens.vim'
+import './callhierarchy.vim' as callhier
+import './typehierarchy.vim' as typehier
+import './inlayhints.vim'
+import './semantichighlight.vim'
+
+# LSP server standard output handler
+def Output_cb(lspserver: dict<any>, chan: channel, msg: any): void
+  if lspserver.debug
+    lspserver.traceLog($'{strftime("%m/%d/%y %T")}: Received {msg->string()}')
+  endif
+  lspserver.data = msg
+  lspserver.processMessages()
+enddef
+
+# LSP server error output handler
+def Error_cb(lspserver: dict<any>, chan: channel, emsg: string): void
+  lspserver.errorLog(emsg)
+enddef
+
+# LSP server exit callback
+def Exit_cb(lspserver: dict<any>, job: job, status: number): void
+  util.WarnMsg($'{strftime("%m/%d/%y %T")}: LSP server ({lspserver.name}) exited with status {status}')
+  lspserver.running = false
+  lspserver.ready = false
+  lspserver.requests = {}
+enddef
+
+# Start a LSP server
+#
+def StartServer(lspserver: dict<any>, bnr: number): number
+  if lspserver.running
+    util.WarnMsg($'LSP server "{lspserver.name}" is already running')
+    return 0
+  endif
+
+  var cmd = [lspserver.path]
+  cmd->extend(lspserver.args)
+
+  var opts = {in_mode: 'lsp',
+		out_mode: 'lsp',
+		err_mode: 'raw',
+		noblock: 1,
+		out_cb: function(Output_cb, [lspserver]),
+		err_cb: function(Error_cb, [lspserver]),
+		exit_cb: function(Exit_cb, [lspserver])}
+
+  lspserver.data = ''
+  lspserver.caps = {}
+  lspserver.nextID = 1
+  lspserver.requests = {}
+  lspserver.omniCompletePending = false
+  lspserver.completionLazyDoc = false
+  lspserver.completionTriggerChars = []
+  lspserver.signaturePopup = -1
+
+  var job = cmd->job_start(opts)
+  if job->job_status() == 'fail'
+    util.ErrMsg($'Failed to start LSP server {lspserver.path}')
+    return 1
+  endif
+
+  # wait a little for the LSP server to start
+  sleep 10m
+
+  lspserver.job = job
+  lspserver.running = true
+
+  lspserver.initServer(bnr)
+
+  return 0
+enddef
+
+# process the "initialize" method reply from the LSP server
+# Result: InitializeResult
+def ServerInitReply(lspserver: dict<any>, initResult: dict<any>): void
+  if initResult->empty()
+    return
+  endif
+
+  var caps: dict<any> = initResult.capabilities
+  lspserver.caps = caps
+
+  for [key, val] in initResult->items()
+    if key == 'capabilities'
+      continue
+    endif
+
+    lspserver.caps[$'~additionalInitResult_{key}'] = val
+  endfor
+
+  capabilities.ProcessServerCaps(lspserver, caps)
+
+  if caps->has_key('completionProvider')
+    lspserver.completionTriggerChars =
+			caps.completionProvider->get('triggerCharacters', [])
+    lspserver.completionLazyDoc =
+			caps.completionProvider->get('resolveProvider', false)
+  endif
+
+  # send a "initialized" notification to server
+  lspserver.sendInitializedNotif()
+  # send any workspace configuration (optional)
+  if !lspserver.workspaceConfig->empty()
+    lspserver.sendWorkspaceConfig()
+  endif
+  lspserver.ready = true
+  if exists($'#User#LspServerReady{lspserver.name}')
+    exe $'doautocmd <nomodeline> User LspServerReady{lspserver.name}'
+  endif
+  # Used internally, and shouldn't be used by users
+  if exists($'#User#LspServerReady_{lspserver.id}')
+    exe $'doautocmd <nomodeline> User LspServerReady_{lspserver.id}'
+  endif
+
+  # set the server debug trace level
+  if lspserver.traceLevel != 'off'
+    lspserver.setTrace(lspserver.traceLevel)
+  endif
+
+  # if the outline window is opened, then request the symbols for the current
+  # buffer
+  if bufwinid('LSP-Outline') != -1
+    lspserver.getDocSymbols(@%, true)
+  endif
+
+  # Update the inlay hints (if enabled)
+  if opt.lspOptions.showInlayHints && (lspserver.isInlayHintProvider
+				    || lspserver.isClangdInlayHintsProvider)
+    inlayhints.LspInlayHintsUpdateNow(bufnr())
+  endif
+enddef
+
+# Request: "initialize"
+# Param: InitializeParams
+def InitServer(lspserver: dict<any>, bnr: number)
+  # interface 'InitializeParams'
+  var initparams: dict<any> = {}
+  initparams.processId = getpid()
+  initparams.clientInfo = {
+	name: 'Vim',
+	version: v:versionlong->string(),
+      }
+
+  # Compute the rootpath (based on the directory of the buffer)
+  var rootPath = ''
+  var rootSearchFiles = lspserver.rootSearchFiles
+  var bufDir = bnr->bufname()->fnamemodify(':p:h')
+  if !rootSearchFiles->empty()
+    rootPath = util.FindNearestRootDir(bufDir, rootSearchFiles)
+  endif
+  if rootPath->empty()
+    var cwd = getcwd()
+
+    # bufDir is within cwd
+    var bufDirPrefix = bufDir[0 : cwd->strcharlen() - 1]
+    if &fileignorecase
+        ? bufDirPrefix ==? cwd
+        : bufDirPrefix == cwd
+      rootPath = cwd
+    else
+      rootPath = bufDir
+    endif
+  endif
+
+  lspserver.workspaceFolders = [rootPath]
+
+  var rootUri = util.LspFileToUri(rootPath)
+  initparams.rootPath = rootPath
+  initparams.rootUri = rootUri
+  initparams.workspaceFolders = [{
+	name: rootPath->fnamemodify(':t'),
+	uri: rootUri
+     }]
+
+  initparams.trace = 'off'
+  initparams.capabilities = capabilities.GetClientCaps()
+  if !lspserver.initializationOptions->empty()
+    initparams.initializationOptions = lspserver.initializationOptions
+  else
+    initparams.initializationOptions = {}
+  endif
+
+  lspserver.rpcInitializeRequest = initparams
+
+  lspserver.rpc_a('initialize', initparams, ServerInitReply)
+enddef
+
+# Send a "initialized" notification to the language server
+def SendInitializedNotif(lspserver: dict<any>)
+  # Notification: 'initialized'
+  # Params: InitializedParams
+  lspserver.sendNotification('initialized')
+enddef
+
+# Request: shutdown
+# Param: void
+def ShutdownServer(lspserver: dict<any>): void
+  lspserver.rpc('shutdown', {})
+enddef
+
+# Send a 'exit' notification to the language server
+def ExitServer(lspserver: dict<any>): void
+  # Notification: 'exit'
+  # Params: void
+  lspserver.sendNotification('exit')
+enddef
+
+# Stop a LSP server
+def StopServer(lspserver: dict<any>): number
+  if !lspserver.running
+    util.WarnMsg($'LSP server {lspserver.name} is not running')
+    return 0
+  endif
+
+  # Send the shutdown request to the server
+  lspserver.shutdownServer()
+
+  # Notify the server to exit
+  lspserver.exitServer()
+
+  # Wait for the server to process the exit notification and exit for a
+  # maximum of 2 seconds.
+  var maxCount: number = 1000
+  while lspserver.job->job_status() == 'run' && maxCount > 0
+    sleep 2m
+    maxCount -= 1
+  endwhile
+
+  if lspserver.job->job_status() == 'run'
+    lspserver.job->job_stop()
+  endif
+  lspserver.running = false
+  lspserver.ready = false
+  lspserver.requests = {}
+  return 0
+enddef
+
+# Set the language server trace level using the '$/setTrace' notification.
+# Supported values for "traceVal" are "off", "messages" and "verbose".
+def SetTrace(lspserver: dict<any>, traceVal: string)
+  # Notification: '$/setTrace'
+  # Params: SetTraceParams
+  var params = {value: traceVal}
+  lspserver.sendNotification('$/setTrace', params)
+enddef
+
+# Log a debug message to the LSP server debug file
+def TraceLog(lspserver: dict<any>, msg: string)
+  if lspserver.debug
+    util.TraceLog(lspserver.logfile, false, msg)
+  endif
+enddef
+
+# Log an error message to the LSP server error file
+def ErrorLog(lspserver: dict<any>, errmsg: string)
+  if lspserver.debug
+    util.TraceLog(lspserver.errfile, true, errmsg)
+  endif
+enddef
+
+# Return the next id for a LSP server request message
+def NextReqID(lspserver: dict<any>): number
+  var id = lspserver.nextID
+  lspserver.nextID = id + 1
+  return id
+enddef
+
+# create a LSP server request message
+def CreateRequest(lspserver: dict<any>, method: string): dict<any>
+  var req = {
+    jsonrpc: '2.0',
+    id: lspserver.nextReqID(),
+    method: method,
+    params: {}
+  }
+
+  # Save the request, so that the corresponding response can be processed
+  lspserver.requests->extend({[req.id->string()]: req})
+
+  return req
+enddef
+
+# create a LSP server response message
+def CreateResponse(lspserver: dict<any>, req_id: number): dict<any>
+  var resp = {
+    jsonrpc: '2.0',
+    id: req_id
+  }
+  return resp
+enddef
+
+# create a LSP server notification message
+def CreateNotification(lspserver: dict<any>, notif: string): dict<any>
+  var req = {
+    jsonrpc: '2.0',
+    method: notif,
+    params: {}
+  }
+
+  return req
+enddef
+
+# send a response message to the server
+def SendResponse(lspserver: dict<any>, request: dict<any>, result: any, error: dict<any>)
+  if (request.id->type() == v:t_string
+	&& (request.id->trim() =~ '[^[:digit:]]\+'
+	    || request.id->trim()->empty()))
+    || (request.id->type() != v:t_string && request.id->type() != v:t_number)
+    util.ErrMsg('request.id of response to LSP server is not a correct number')
+    return
+  endif
+  var resp: dict<any> = lspserver.createResponse(
+	    request.id->type() == v:t_string ? request.id->str2nr() : request.id)
+  if error->empty()
+    resp->extend({result: result})
+  else
+    resp->extend({error: error})
+  endif
+  lspserver.sendMessage(resp)
+enddef
+
+# Send a request message to LSP server
+def SendMessage(lspserver: dict<any>, content: dict<any>): void
+  var job = lspserver.job
+  if job->job_status() != 'run'
+    # LSP server has exited
+    return
+  endif
+  job->ch_sendexpr(content)
+  if content->has_key('id')
+    if lspserver.debug
+      lspserver.traceLog($'{strftime("%m/%d/%y %T")}: Sent {content->string()}')
+    endif
+  endif
+enddef
+
+# Send a notification message to the language server
+def SendNotification(lspserver: dict<any>, method: string, params: any = {})
+  var notif: dict<any> = CreateNotification(lspserver, method)
+  notif.params->extend(params)
+  lspserver.sendMessage(notif)
+enddef
+
+# Translate an LSP error code into a readable string
+def LspGetErrorMessage(errcode: number): string
+  var errmap = {
+    -32001: 'UnknownErrorCode',
+    -32002: 'ServerNotInitialized',
+    -32600: 'InvalidRequest',
+    -32601: 'MethodNotFound',
+    -32602: 'InvalidParams',
+    -32603: 'InternalError',
+    -32700: 'ParseError',
+    -32800: 'RequestCancelled',
+    -32801: 'ContentModified',
+    -32802: 'ServerCancelled',
+    -32803: 'RequestFailed'
+  }
+
+  return errmap->get(errcode, errcode->string())
+enddef
+
+# Process a LSP server response error and display an error message.
+def ProcessLspServerError(method: string, responseError: dict<any>)
+  # request failed
+  var emsg: string = responseError.message
+  emsg ..= $', error = {LspGetErrorMessage(responseError.code)}'
+  if responseError->has_key('data')
+    emsg ..= $', data = {responseError.data->string()}'
+  endif
+  util.ErrMsg($'request {method} failed ({emsg})')
+enddef
+
+# Send a sync RPC request message to the LSP server and return the received
+# reply.  In case of an error, an empty Dict is returned.
+def Rpc(lspserver: dict<any>, method: string, params: any, handleError: bool = true): dict<any>
+  var req = {
+    method: method,
+    params: params
+  }
+
+  var job = lspserver.job
+  if job->job_status() != 'run'
+    # LSP server has exited
+    return {}
+  endif
+
+  if lspserver.debug
+    lspserver.traceLog($'{strftime("%m/%d/%y %T")}: Sent {req->string()}')
+  endif
+
+  # Do the synchronous RPC call
+  var reply = job->ch_evalexpr(req)
+
+  if lspserver.debug
+    lspserver.traceLog($'{strftime("%m/%d/%y %T")}: Received {reply->string()}')
+  endif
+
+  if reply->has_key('result')
+    # successful reply
+    return reply
+  endif
+
+  if reply->has_key('error') && handleError
+    # request failed
+    ProcessLspServerError(method, reply.error)
+  endif
+
+  return {}
+enddef
+
+# LSP server asynchronous RPC callback
+def AsyncRpcCb(lspserver: dict<any>, method: string, RpcCb: func, chan: channel, reply: dict<any>)
+  if lspserver.debug
+    lspserver.traceLog($'{strftime("%m/%d/%y %T")}: Received {reply->string()}')
+  endif
+
+  if reply->empty()
+    return
+  endif
+
+  if reply->has_key('error')
+    # request failed
+    ProcessLspServerError(method, reply.error)
+    return
+  endif
+
+  if !reply->has_key('result')
+    util.ErrMsg($'request {method} failed (no result)')
+    return
+  endif
+
+  RpcCb(lspserver, reply.result)
+enddef
+
+# Send a async RPC request message to the LSP server with a callback function.
+# Returns the LSP message id.  This id can be used to cancel the RPC request
+# (if needed).  Returns -1 on error.
+def AsyncRpc(lspserver: dict<any>, method: string, params: any, Cbfunc: func): number
+  var req = {
+    method: method,
+    params: params
+  }
+
+  var job = lspserver.job
+  if job->job_status() != 'run'
+    # LSP server has exited
+    return -1
+  endif
+
+  if lspserver.debug
+    lspserver.traceLog($'{strftime("%m/%d/%y %T")}: Sent {req->string()}')
+  endif
+
+  # Do the asynchronous RPC call
+  var Fn = function('AsyncRpcCb', [lspserver, method, Cbfunc])
+
+  var reply: dict<any>
+  if get(g:, 'LSPTest')
+    # When running LSP tests, make this a synchronous RPC call
+    reply = Rpc(lspserver, method, params)
+    Fn(test_null_channel(), reply)
+  else
+    # Otherwise, make an asynchronous RPC call
+    reply = job->ch_sendexpr(req, {callback: Fn})
+  endif
+  if reply->empty()
+    return -1
+  endif
+
+  return reply.id
+enddef
+
+# Wait for a response message from the LSP server for the request "req"
+# Waits for a maximum of 5 seconds
+def WaitForResponse(lspserver: dict<any>, req: dict<any>)
+  var maxCount: number = 2500
+  var key: string = req.id->string()
+
+  while lspserver.requests->has_key(key) && maxCount > 0
+    sleep 2m
+    maxCount -= 1
+  endwhile
+enddef
+
+# Returns true when the "lspserver" has "feature" enabled.
+# By default, all the features of a lsp server are enabled.
+def FeatureEnabled(lspserver: dict<any>, feature: string): bool
+  return lspserver.features->get(feature, true)
+enddef
+
+# Retrieve the Workspace configuration asked by the server.
+# Request: workspace/configuration
+def WorkspaceConfigGet(lspserver: dict<any>, configItem: dict<any>): dict<any>
+  if lspserver.workspaceConfig->empty()
+    return {}
+  endif
+  if !configItem->has_key('section') || configItem.section->empty()
+    return lspserver.workspaceConfig
+  endif
+  var config: dict<any> = lspserver.workspaceConfig
+  for part in configItem.section->split('\.')
+    if !config->has_key(part)
+      return {}
+    endif
+    config = config[part]
+  endfor
+  return config
+enddef
+
+# Update semantic highlighting for buffer "bnr"
+# Request: textDocument/semanticTokens/full or
+#	   textDocument/semanticTokens/full/delta
+def SemanticHighlightUpdate(lspserver: dict<any>, bnr: number)
+  if !lspserver.isSemanticTokensProvider
+    return
+  endif
+
+  # Send the pending buffer changes to the language server
+  bnr->listener_flush()
+
+  var method = 'textDocument/semanticTokens/full'
+  var params: dict<any> = {
+    textDocument: {
+      uri: util.LspBufnrToUri(bnr)
+    }
+  }
+
+  # Should we send a semantic tokens delta request instead of a full request?
+  if lspserver.semanticTokensDelta
+    var prevResultId: string = ''
+    prevResultId = bnr->getbufvar('LspSemanticResultId', '')
+    if prevResultId != ''
+      # semantic tokens delta request
+      params.previousResultId = prevResultId
+      method ..= '/delta'
+    endif
+  endif
+
+  var reply = lspserver.rpc(method, params)
+
+  if reply->empty() || reply.result->empty()
+    return
+  endif
+
+  semantichighlight.UpdateTokens(lspserver, bnr, reply.result)
+enddef
+
+# Send a "workspace/didChangeConfiguration" notification to the language
+# server.
+def SendWorkspaceConfig(lspserver: dict<any>)
+  # Params: DidChangeConfigurationParams
+  var params = {settings: lspserver.workspaceConfig}
+  lspserver.sendNotification('workspace/didChangeConfiguration', params)
+enddef
+
+# Send a file/document opened notification to the language server.
+def TextdocDidOpen(lspserver: dict<any>, bnr: number, ftype: string): void
+  # Notification: 'textDocument/didOpen'
+  # Params: DidOpenTextDocumentParams
+  var params = {
+    textDocument: {
+      uri: util.LspBufnrToUri(bnr),
+      languageId: ftype,
+      # Use Vim 'changedtick' as the LSP document version number
+      version: bnr->getbufvar('changedtick'),
+      text: bnr->getbufline(1, '$')->join("\n") .. "\n"
+    }
+  }
+  lspserver.sendNotification('textDocument/didOpen', params)
+enddef
+
+# Send a file/document closed notification to the language server.
+def TextdocDidClose(lspserver: dict<any>, bnr: number): void
+  # Notification: 'textDocument/didClose'
+  # Params: DidCloseTextDocumentParams
+  var params = {
+    textDocument: {
+      uri: util.LspBufnrToUri(bnr)
+    }
+  }
+  lspserver.sendNotification('textDocument/didClose', params)
+enddef
+
+# Send a file/document change notification to the language server.
+# Params: DidChangeTextDocumentParams
+def TextdocDidChange(lspserver: dict<any>, bnr: number, start: number,
+			end: number, added: number,
+			changes: list<dict<number>>): void
+  # Notification: 'textDocument/didChange'
+  # Params: DidChangeTextDocumentParams
+
+  # var changeset: list<dict<any>>
+
+  ##### FIXME: Sending specific buffer changes to the LSP server doesn't
+  ##### work properly as the computed line range numbers is not correct.
+  ##### For now, send the entire buffer content to LSP server.
+  # #     Range
+  # for change in changes
+  #   var lines: string
+  #   var start_lnum: number
+  #   var end_lnum: number
+  #   var start_col: number
+  #   var end_col: number
+  #   if change.added == 0
+  #     # lines changed
+  #     start_lnum =  change.lnum - 1
+  #     end_lnum = change.end - 1
+  #     lines = getbufline(bnr, change.lnum, change.end - 1)->join("\n") .. "\n"
+  #     start_col = 0
+  #     end_col = 0
+  #   elseif change.added > 0
+  #     # lines added
+  #     start_lnum = change.lnum - 1
+  #     end_lnum = change.lnum - 1
+  #     start_col = 0
+  #     end_col = 0
+  #     lines = getbufline(bnr, change.lnum, change.lnum + change.added - 1)->join("\n") .. "\n"
+  #   else
+  #     # lines removed
+  #     start_lnum = change.lnum - 1
+  #     end_lnum = change.lnum + (-change.added) - 1
+  #     start_col = 0
+  #     end_col = 0
+  #     lines = ''
+  #   endif
+  #   var range: dict<dict<number>> = {'start': {'line': start_lnum, 'character': start_col}, 'end': {'line': end_lnum, 'character': end_col}}
+  #   changeset->add({'range': range, 'text': lines})
+  # endfor
+
+  var params = {
+    textDocument: {
+      uri: util.LspBufnrToUri(bnr),
+      # Use Vim 'changedtick' as the LSP document version number
+      version: bnr->getbufvar('changedtick')
+    },
+    contentChanges: [
+      {text: bnr->getbufline(1, '$')->join("\n") .. "\n"}
+    ]
+  }
+  lspserver.sendNotification('textDocument/didChange', params)
+enddef
+
+# Return the current cursor position as a LSP position.
+# find_ident will search for a identifier in front of the cursor, just like
+# CTRL-] and c_CTRL-R_CTRL-W does.
+#
+# LSP line and column numbers start from zero, whereas Vim line and column
+# numbers start from one. The LSP column number is the character index in the
+# line and not the byte index in the line.
+def GetPosition(lspserver: dict<any>, find_ident: bool): dict<number>
+  var lnum: number = line('.') - 1
+  var col: number = charcol('.') - 1
+  var line = getline('.')
+
+  if find_ident
+    # 1. skip to start of identifier
+    while line[col] != '' && line[col] !~ '\k'
+      col = col + 1
+    endwhile
+
+    # 2. back up to start of identifier
+    while col > 0 && line[col - 1] =~ '\k'
+      col = col - 1
+    endwhile
+  endif
+
+  # Compute character index counting composing characters as separate
+  # characters
+  var pos = {line: lnum, character: util.GetCharIdxWithCompChar(line, col)}
+  lspserver.encodePosition(bufnr(), pos)
+
+  return pos
+enddef
+
+# Return the current file name and current cursor position as a LSP
+# TextDocumentPositionParams structure
+def GetTextDocPosition(lspserver: dict<any>, find_ident: bool): dict<dict<any>>
+  # interface TextDocumentIdentifier
+  # interface Position
+  return {textDocument: {uri: util.LspFileToUri(@%)},
+	  position: lspserver.getPosition(find_ident)}
+enddef
+
+# Get a list of completion items.
+# Request: "textDocument/completion"
+# Param: CompletionParams
+def GetCompletion(lspserver: dict<any>, triggerKind_arg: number, triggerChar: string): void
+  # Check whether LSP server supports completion
+  if !lspserver.isCompletionProvider
+    util.ErrMsg('LSP server does not support completion')
+    return
+  endif
+
+  var fname = @%
+  if fname->empty()
+    return
+  endif
+
+  # interface CompletionParams
+  #   interface TextDocumentPositionParams
+  var params = lspserver.getTextDocPosition(false)
+  #   interface CompletionContext
+  params.context = {triggerKind: triggerKind_arg, triggerCharacter: triggerChar}
+
+  lspserver.rpc_a('textDocument/completion', params,
+			completion.CompletionReply)
+enddef
+
+# Get lazy properties for a completion item.
+# Request: "completionItem/resolve"
+# Param: CompletionItem
+def ResolveCompletion(lspserver: dict<any>, item: dict<any>, sync: bool = false): dict<any>
+  # Check whether LSP server supports completion item resolve
+  if !lspserver.isCompletionResolveProvider
+    return {}
+  endif
+
+  # interface CompletionItem
+  if sync
+    var reply = lspserver.rpc('completionItem/resolve', item)
+    if !reply->empty() && !reply.result->empty()
+      return reply.result
+    endif
+  else
+    lspserver.rpc_a('completionItem/resolve', item,
+			  completion.CompletionResolveReply)
+  endif
+  return {}
+enddef
+
+# Jump to or peek a symbol location.
+#
+# Send 'msg' to a LSP server and process the reply.  'msg' is one of the
+# following:
+#   textDocument/definition
+#   textDocument/declaration
+#   textDocument/typeDefinition
+#   textDocument/implementation
+#
+# Process the LSP server reply and jump to the symbol location.  Before
+# jumping to the symbol location, save the current cursor position in the tag
+# stack.
+#
+# If 'peekSymbol' is true, then display the symbol location in the preview
+# window but don't jump to the symbol location.
+#
+# Result: Location | Location[] | LocationLink[] | null
+def GotoSymbolLoc(lspserver: dict<any>, msg: string, peekSymbol: bool,
+		  cmdmods: string, count: number)
+  var reply = lspserver.rpc(msg, lspserver.getTextDocPosition(true), false)
+  if reply->empty() || reply.result->empty()
+    var emsg: string
+    if msg == 'textDocument/declaration'
+      emsg = 'symbol declaration is not found'
+    elseif msg == 'textDocument/typeDefinition'
+      emsg = 'symbol type definition is not found'
+    elseif msg == 'textDocument/implementation'
+      emsg = 'symbol implementation is not found'
+    else
+      emsg = 'symbol definition is not found'
+    endif
+
+    util.WarnMsg(emsg)
+    return
+  endif
+
+  var result = reply.result
+  var location: dict<any>
+  if result->type() == v:t_list
+    if count == 0
+      # When there are multiple symbol locations, and a specific one isn't
+      # requested with 'count', display the locations in a location list.
+      if result->len() > 1
+        var title: string = ''
+        if msg == 'textDocument/declaration'
+          title = 'Declarations'
+        elseif msg == 'textDocument/typeDefinition'
+          title = 'Type Definitions'
+        elseif msg == 'textDocument/implementation'
+          title = 'Implementations'
+        else
+          title = 'Definitions'
+        endif
+
+	if lspserver.needOffsetEncoding
+	  # Decode the position encoding in all the symbol locations
+	  result->map((_, loc) => {
+	      lspserver.decodeLocation(loc)
+	      return loc
+	    })
+	endif
+
+        symbol.ShowLocations(lspserver, result, peekSymbol, title)
+        return
+      endif
+    endif
+
+    # Select the location requested in 'count'
+    var idx = count - 1
+    if idx >= result->len()
+      idx = result->len() - 1
+    endif
+    location = result[idx]
+  else
+    location = result
+  endif
+  lspserver.decodeLocation(location)
+
+  symbol.GotoSymbol(lspserver, location, peekSymbol, cmdmods)
+enddef
+
+# Request: "textDocument/definition"
+# Param: DefinitionParams
+def GotoDefinition(lspserver: dict<any>, peek: bool, cmdmods: string, count: number)
+  # Check whether LSP server supports jumping to a definition
+  if !lspserver.isDefinitionProvider
+    util.ErrMsg('Jumping to a symbol definition is not supported')
+    return
+  endif
+
+  # interface DefinitionParams
+  #   interface TextDocumentPositionParams
+  GotoSymbolLoc(lspserver, 'textDocument/definition', peek, cmdmods, count)
+enddef
+
+# Request: "textDocument/declaration"
+# Param: DeclarationParams
+def GotoDeclaration(lspserver: dict<any>, peek: bool, cmdmods: string, count: number)
+  # Check whether LSP server supports jumping to a declaration
+  if !lspserver.isDeclarationProvider
+    util.ErrMsg('Jumping to a symbol declaration is not supported')
+    return
+  endif
+
+  # interface DeclarationParams
+  #   interface TextDocumentPositionParams
+  GotoSymbolLoc(lspserver, 'textDocument/declaration', peek, cmdmods, count)
+enddef
+
+# Request: "textDocument/typeDefinition"
+# Param: TypeDefinitionParams
+def GotoTypeDef(lspserver: dict<any>, peek: bool, cmdmods: string, count: number)
+  # Check whether LSP server supports jumping to a type definition
+  if !lspserver.isTypeDefinitionProvider
+    util.ErrMsg('Jumping to a symbol type definition is not supported')
+    return
+  endif
+
+  # interface TypeDefinitionParams
+  #   interface TextDocumentPositionParams
+  GotoSymbolLoc(lspserver, 'textDocument/typeDefinition', peek, cmdmods, count)
+enddef
+
+# Request: "textDocument/implementation"
+# Param: ImplementationParams
+def GotoImplementation(lspserver: dict<any>, peek: bool, cmdmods: string, count: number)
+  # Check whether LSP server supports jumping to a implementation
+  if !lspserver.isImplementationProvider
+    util.ErrMsg('Jumping to a symbol implementation is not supported')
+    return
+  endif
+
+  # interface ImplementationParams
+  #   interface TextDocumentPositionParams
+  GotoSymbolLoc(lspserver, 'textDocument/implementation', peek, cmdmods, count)
+enddef
+
+# Request: "textDocument/switchSourceHeader"
+# Param: TextDocumentIdentifier
+# Clangd specific extension
+def SwitchSourceHeader(lspserver: dict<any>)
+  var param = {
+    uri: util.LspFileToUri(@%)
+  }
+  var reply = lspserver.rpc('textDocument/switchSourceHeader', param)
+  if reply->empty() || reply.result->empty()
+    util.WarnMsg('Source/Header file is not found')
+    return
+  endif
+
+  # process the 'textDocument/switchSourceHeader' reply from the LSP server
+  # Result: URI | null
+  var fname = util.LspUriToFile(reply.result)
+  # TODO: Add support for cmd modifiers
+  if (&modified && !&hidden) || &buftype != ''
+    # if the current buffer has unsaved changes and 'hidden' is not set,
+    # or if the current buffer is a special buffer, then ask to save changes
+    exe $'confirm edit {fname}'
+  else
+    exe $'edit {fname}'
+  endif
+enddef
+
+# get symbol signature help.
+# Request: "textDocument/signatureHelp"
+# Param: SignatureHelpParams
+def ShowSignature(lspserver: dict<any>): void
+  # Check whether LSP server supports signature help
+  if !lspserver.isSignatureHelpProvider
+    util.ErrMsg('LSP server does not support signature help')
+    return
+  endif
+
+  # interface SignatureHelpParams
+  #   interface TextDocumentPositionParams
+  var params = lspserver.getTextDocPosition(false)
+  lspserver.rpc_a('textDocument/signatureHelp', params,
+			signature.SignatureHelp)
+enddef
+
+# Send a file/document saved notification to the language server
+def DidSaveFile(lspserver: dict<any>, bnr: number): void
+  # Check whether the LSP server supports the didSave notification
+  if !lspserver.supportsDidSave
+    # LSP server doesn't support text document synchronization
+    return
+  endif
+
+  # Notification: 'textDocument/didSave'
+  # Params: DidSaveTextDocumentParams
+  var params: dict<any> = {textDocument: {uri: util.LspBufnrToUri(bnr)}}
+
+  if lspserver.caps.textDocumentSync->type() == v:t_dict
+      && lspserver.caps.textDocumentSync->has_key('save')
+    if lspserver.caps.textDocumentSync.save->type() == v:t_dict
+	&& lspserver.caps.textDocumentSync.save->has_key('includeText')
+	&& lspserver.caps.textDocumentSync.save.includeText
+      params.text = bnr->getbufline(1, '$')->join("\n") .. "\n"
+    endif
+  endif
+
+  lspserver.sendNotification('textDocument/didSave', params)
+enddef
+
+# get the hover information
+# Request: "textDocument/hover"
+# Param: HoverParams
+def ShowHoverInfo(lspserver: dict<any>, cmdmods: string): void
+  # Check whether LSP server supports getting hover information.
+  # caps->hoverProvider can be a "boolean" or "HoverOptions"
+  if !lspserver.isHoverProvider
+    return
+  endif
+
+  # interface HoverParams
+  #   interface TextDocumentPositionParams
+  var params = lspserver.getTextDocPosition(false)
+  lspserver.rpc_a('textDocument/hover', params, (_, reply) => {
+    hover.HoverReply(lspserver, reply, cmdmods)
+  })
+enddef
+
+# Request: "textDocument/references"
+# Param: ReferenceParams
+def ShowReferences(lspserver: dict<any>, peek: bool): void
+  # Check whether LSP server supports getting reference information
+  if !lspserver.isReferencesProvider
+    util.ErrMsg('LSP server does not support showing references')
+    return
+  endif
+
+  # interface ReferenceParams
+  #   interface TextDocumentPositionParams
+  var param: dict<any>
+  param = lspserver.getTextDocPosition(true)
+  param.context = {includeDeclaration: true}
+  var reply = lspserver.rpc('textDocument/references', param)
+
+  # Result: Location[] | null
+  if reply->empty() || reply.result->empty()
+    util.WarnMsg('No references found')
+    return
+  endif
+
+  if lspserver.needOffsetEncoding
+    # Decode the position encoding in all the reference locations
+    reply.result->map((_, loc) => {
+      lspserver.decodeLocation(loc)
+      return loc
+    })
+  endif
+
+  symbol.ShowLocations(lspserver, reply.result, peek, 'Symbol References')
+enddef
+
+# process the 'textDocument/documentHighlight' reply from the LSP server
+# Result: DocumentHighlight[] | null
+def DocHighlightReply(lspserver: dict<any>, docHighlightReply: any,
+                      bnr: number, cmdmods: string): void
+  if docHighlightReply->empty()
+    if cmdmods !~ 'silent'
+      util.WarnMsg($'No highlight for the current position')
+    endif
+    return
+  endif
+
+  for docHL in docHighlightReply
+    lspserver.decodeRange(bnr, docHL.range)
+    var kind: number = docHL->get('kind', 1)
+    var propName: string
+    if kind == 2
+      # Read-access
+      propName = 'LspReadRef'
+    elseif kind == 3
+      # Write-access
+      propName = 'LspWriteRef'
+    else
+      # textual reference
+      propName = 'LspTextRef'
+    endif
+    try
+      var docHL_range = docHL.range
+      var docHL_start = docHL_range.start
+      var docHL_end = docHL_range.end
+      prop_add(docHL_start.line + 1,
+                  util.GetLineByteFromPos(bnr, docHL_start) + 1,
+                  {end_lnum: docHL_end.line + 1,
+                    end_col: util.GetLineByteFromPos(bnr, docHL_end) + 1,
+                    bufnr: bnr,
+                    type: propName})
+    catch /E966\|E964/ # Invalid lnum | Invalid col
+      # Highlight replies arrive asynchronously and the document might have
+      # been modified in the mean time.  As the reply is stale, ignore invalid
+      # line number and column number errors.
+    endtry
+  endfor
+enddef
+
+# Request: "textDocument/documentHighlight"
+# Param: DocumentHighlightParams
+def DocHighlight(lspserver: dict<any>, bnr: number, cmdmods: string): void
+  # Check whether LSP server supports getting highlight information
+  if !lspserver.isDocumentHighlightProvider
+    util.ErrMsg('LSP server does not support document highlight')
+    return
+  endif
+
+  # Send the pending buffer changes to the language server
+  bnr->listener_flush()
+
+  # interface DocumentHighlightParams
+  #   interface TextDocumentPositionParams
+  var params = lspserver.getTextDocPosition(false)
+  lspserver.rpc_a('textDocument/documentHighlight', params, (_, reply) => {
+    DocHighlightReply(lspserver, reply, bufnr(), cmdmods)
+  })
+enddef
+
+# Request: "textDocument/documentSymbol"
+# Param: DocumentSymbolParams
+def GetDocSymbols(lspserver: dict<any>, fname: string, showOutline: bool): void
+  # Check whether LSP server supports getting document symbol information
+  if !lspserver.isDocumentSymbolProvider
+    util.ErrMsg('LSP server does not support getting list of symbols')
+    return
+  endif
+
+  # interface DocumentSymbolParams
+  # interface TextDocumentIdentifier
+  var params = {textDocument: {uri: util.LspFileToUri(fname)}}
+  lspserver.rpc_a('textDocument/documentSymbol', params, (_, reply) => {
+    if showOutline
+      symbol.DocSymbolOutline(lspserver, reply, fname)
+    else
+      symbol.DocSymbolPopup(lspserver, reply, fname)
+    endif
+  })
+enddef
+
+# Request: "textDocument/formatting"
+# Param: DocumentFormattingParams
+# or
+# Request: "textDocument/rangeFormatting"
+# Param: DocumentRangeFormattingParams
+def TextDocFormat(lspserver: dict<any>, fname: string, rangeFormat: bool,
+				start_lnum: number, end_lnum: number)
+  # Check whether LSP server supports formatting documents
+  if !lspserver.isDocumentFormattingProvider
+    util.ErrMsg('LSP server does not support formatting documents')
+    return
+  endif
+
+  var cmd: string
+  if rangeFormat
+    cmd = 'textDocument/rangeFormatting'
+  else
+    cmd = 'textDocument/formatting'
+  endif
+
+  # interface DocumentFormattingParams
+  #   interface TextDocumentIdentifier
+  #   interface FormattingOptions
+  var fmtopts: dict<any> = {
+    tabSize: shiftwidth(),
+    insertSpaces: &expandtab ? true : false,
+  }
+  var param = {
+    textDocument: {
+      uri: util.LspFileToUri(fname)
+    },
+    options: fmtopts
+  }
+
+  if rangeFormat
+    var r: dict<dict<number>> = {
+	start: {line: start_lnum - 1, character: 0},
+	end: {line: end_lnum - 1, character: charcol([end_lnum, '$']) - 1}}
+    param.range = r
+  endif
+
+  var reply = lspserver.rpc(cmd, param)
+
+  # result: TextEdit[] | null
+
+  if reply->empty() || reply.result->empty()
+    # nothing to format
+    return
+  endif
+
+  var bnr: number = fname->bufnr()
+  if bnr == -1
+    # file is already removed
+    return
+  endif
+
+  if lspserver.needOffsetEncoding
+    # Decode the position encoding in all the reference locations
+    reply.result->map((_, textEdit) => {
+      lspserver.decodeRange(bnr, textEdit.range)
+      return textEdit
+    })
+  endif
+
+  # interface TextEdit
+  # Apply each of the text edit operations
+  var save_cursor: list<number> = getcurpos()
+  textedit.ApplyTextEdits(bnr, reply.result)
+  save_cursor->setpos('.')
+enddef
+
+# Request: "textDocument/prepareCallHierarchy"
+def PrepareCallHierarchy(lspserver: dict<any>): dict<any>
+  # interface CallHierarchyPrepareParams
+  #   interface TextDocumentPositionParams
+  var param: dict<any>
+  param = lspserver.getTextDocPosition(false)
+  var reply = lspserver.rpc('textDocument/prepareCallHierarchy', param)
+  if reply->empty() || reply.result->empty()
+    return {}
+  endif
+
+  # Result: CallHierarchyItem[] | null
+  var choice: number = 1
+  if reply.result->len() > 1
+    var items: list<string> = ['Select a Call Hierarchy Item:']
+    for i in reply.result->len()->range()
+      items->add(printf("%d. %s", i + 1, reply.result[i].name))
+    endfor
+    choice = items->inputlist()
+    if choice < 1 || choice > items->len()
+      return {}
+    endif
+  endif
+
+  return reply.result[choice - 1]
+enddef
+
+# Request: "callHierarchy/incomingCalls"
+def IncomingCalls(lspserver: dict<any>, fname: string)
+  # Check whether LSP server supports call hierarchy
+  if !lspserver.isCallHierarchyProvider
+    util.ErrMsg('LSP server does not support call hierarchy')
+    return
+  endif
+
+  callhier.IncomingCalls(lspserver)
+enddef
+
+def GetIncomingCalls(lspserver: dict<any>, item_arg: dict<any>): any
+  # Request: "callHierarchy/incomingCalls"
+  # Param: CallHierarchyIncomingCallsParams
+  var param = {
+    item: item_arg
+  }
+  var reply = lspserver.rpc('callHierarchy/incomingCalls', param)
+  if reply->empty()
+    return null
+  endif
+
+  if lspserver.needOffsetEncoding
+    # Decode the position encoding in all the incoming call locations
+    var bnr = util.LspUriToBufnr(item_arg.uri)
+    reply.result->map((_, hierItem) => {
+      lspserver.decodeRange(bnr, hierItem.from.range)
+      return hierItem
+    })
+  endif
+
+  return reply.result
+enddef
+
+# Request: "callHierarchy/outgoingCalls"
+def OutgoingCalls(lspserver: dict<any>, fname: string)
+  # Check whether LSP server supports call hierarchy
+  if !lspserver.isCallHierarchyProvider
+    util.ErrMsg('LSP server does not support call hierarchy')
+    return
+  endif
+
+  callhier.OutgoingCalls(lspserver)
+enddef
+
+def GetOutgoingCalls(lspserver: dict<any>, item_arg: dict<any>): any
+  # Request: "callHierarchy/outgoingCalls"
+  # Param: CallHierarchyOutgoingCallsParams
+  var param = {
+    item: item_arg
+  }
+  var reply = lspserver.rpc('callHierarchy/outgoingCalls', param)
+  if reply->empty()
+    return null
+  endif
+
+  if lspserver.needOffsetEncoding
+    # Decode the position encoding in all the outgoing call locations
+    var bnr = util.LspUriToBufnr(item_arg.uri)
+    reply.result->map((_, hierItem) => {
+      lspserver.decodeRange(bnr, hierItem.to.range)
+      return hierItem
+    })
+  endif
+
+  return reply.result
+enddef
+
+# Request: "textDocument/inlayHint"
+# Inlay hints.
+def InlayHintsShow(lspserver: dict<any>, bnr: number)
+  # Check whether LSP server supports type hierarchy
+  if !lspserver.isInlayHintProvider && !lspserver.isClangdInlayHintsProvider
+    util.ErrMsg('LSP server does not support inlay hint')
+    return
+  endif
+
+  # Send the pending buffer changes to the language server
+  bnr->listener_flush()
+
+  var binfo = bnr->getbufinfo()
+  if binfo->empty()
+    return
+  endif
+  var lastlnum = binfo[0].linecount
+  var lastline = bnr->getbufline('$')
+  var lastcol = 1
+  if !lastline->empty() && !lastline[0]->empty()
+    lastcol = lastline[0]->strchars()
+  endif
+  var param = {
+      textDocument: {uri: util.LspBufnrToUri(bnr)},
+      range:
+      {
+	start: {line: 0, character: 0},
+	end: {line: lastlnum - 1, character: lastcol - 1}
+      }
+  }
+
+  lspserver.encodeRange(bnr, param.range)
+
+  var msg: string
+  if lspserver.isClangdInlayHintsProvider
+    # clangd-style inlay hints
+    msg = 'clangd/inlayHints'
+  else
+    msg = 'textDocument/inlayHint'
+  endif
+  var reply = lspserver.rpc_a(msg, param, (_, reply) => {
+    inlayhints.InlayHintsReply(lspserver, bnr, reply)
+  })
+enddef
+
+def DecodeTypeHierarchy(lspserver: dict<any>, isSuper: bool, typeHier: dict<any>)
+  if !lspserver.needOffsetEncoding
+    return
+  endif
+  var bnr = util.LspUriToBufnr(typeHier.uri)
+  lspserver.decodeRange(bnr, typeHier.range)
+  lspserver.decodeRange(bnr, typeHier.selectionRange)
+  var subType: list<dict<any>>
+  if isSuper
+    subType = typeHier->get('parents', [])
+  else
+    subType = typeHier->get('children', [])
+  endif
+  if !subType->empty()
+    # Decode the position encoding in all the type hierarchy items
+    subType->map((_, typeHierItem) => {
+        DecodeTypeHierarchy(lspserver, isSuper, typeHierItem)
+	return typeHierItem
+      })
+  endif
+enddef
+
+# Request: "textDocument/typehierarchy"
+# Support the clangd version of type hierarchy retrieval method.
+# The method described in the LSP 3.17.0 standard is not supported as clangd
+# doesn't support that method.
+def TypeHierarchy(lspserver: dict<any>, direction: number)
+  # Check whether LSP server supports type hierarchy
+  if !lspserver.isTypeHierarchyProvider
+    util.ErrMsg('LSP server does not support type hierarchy')
+    return
+  endif
+
+  # interface TypeHierarchy
+  #   interface TextDocumentPositionParams
+  var param: dict<any>
+  param = lspserver.getTextDocPosition(false)
+  # 0: children, 1: parent, 2: both
+  param.direction = direction
+  param.resolve = 5
+  var reply = lspserver.rpc('textDocument/typeHierarchy', param)
+  if reply->empty() || reply.result->empty()
+    util.WarnMsg('No type hierarchy available')
+    return
+  endif
+
+  var isSuper = (direction == 1)
+
+  DecodeTypeHierarchy(lspserver, isSuper, reply.result)
+
+  typehier.ShowTypeHierarchy(lspserver, isSuper, reply.result)
+enddef
+
+# Decode the ranges in "WorkspaceEdit"
+def DecodeWorkspaceEdit(lspserver: dict<any>, workspaceEdit: dict<any>)
+  if !lspserver.needOffsetEncoding
+    return
+  endif
+  if workspaceEdit->has_key('changes')
+    for [uri, changes] in workspaceEdit.changes->items()
+      var bnr: number = util.LspUriToBufnr(uri)
+      if bnr <= 0
+	continue
+      endif
+      # Decode the position encoding in all the text edit locations
+      changes->map((_, textEdit) => {
+	lspserver.decodeRange(bnr, textEdit.range)
+	return textEdit
+      })
+    endfor
+  endif
+
+  if workspaceEdit->has_key('documentChanges')
+    for change in workspaceEdit.documentChanges
+      if !change->has_key('kind')
+	var bnr: number = util.LspUriToBufnr(change.textDocument.uri)
+	if bnr <= 0
+	  continue
+	endif
+	# Decode the position encoding in all the text edit locations
+	change.edits->map((_, textEdit) => {
+	  lspserver.decodeRange(bnr, textEdit.range)
+	  return textEdit
+	})
+      endif
+    endfor
+  endif
+enddef
+
+# Request: "textDocument/rename"
+# Param: RenameParams
+def RenameSymbol(lspserver: dict<any>, newName: string)
+  # Check whether LSP server supports rename operation
+  if !lspserver.isRenameProvider
+    util.ErrMsg('LSP server does not support rename operation')
+    return
+  endif
+
+  # interface RenameParams
+  #   interface TextDocumentPositionParams
+  var param: dict<any> = {}
+  param = lspserver.getTextDocPosition(true)
+  param.newName = newName
+
+  var reply = lspserver.rpc('textDocument/rename', param)
+
+  # Result: WorkspaceEdit | null
+  if reply->empty() || reply.result->empty()
+    # nothing to rename
+    return
+  endif
+
+  # result: WorkspaceEdit
+  DecodeWorkspaceEdit(lspserver, reply.result)
+  textedit.ApplyWorkspaceEdit(reply.result)
+enddef
+
+# Decode the range in "CodeAction"
+def DecodeCodeAction(lspserver: dict<any>, actionList: list<dict<any>>)
+  if !lspserver.needOffsetEncoding
+    return
+  endif
+  actionList->map((_, act) => {
+      if !act->has_key('disabled') && act->has_key('edit')
+	DecodeWorkspaceEdit(lspserver, act.edit)
+      endif
+      return act
+    })
+enddef
+
+# Request: "textDocument/codeAction"
+# Param: CodeActionParams
+def CodeAction(lspserver: dict<any>, fname_arg: string, line1: number,
+		line2: number, query: string)
+  # Check whether LSP server supports code action operation
+  if !lspserver.isCodeActionProvider
+    util.ErrMsg('LSP server does not support code action operation')
+    return
+  endif
+
+  # interface CodeActionParams
+  var params: dict<any> = {}
+  var fname: string = fname_arg->fnamemodify(':p')
+  var bnr: number = fname_arg->bufnr()
+  var r: dict<dict<number>> = {
+    start: {
+      line: line1 - 1,
+      character: line1 == line2 ? util.GetCharIdxWithCompChar(getline('.'), charcol('.') - 1) : 0
+    },
+    end: {
+      line: line2 - 1,
+      character: util.GetCharIdxWithCompChar(getline(line2), charcol([line2, '$']) - 1)
+    }
+  }
+  lspserver.encodeRange(bnr, r)
+  params->extend({textDocument: {uri: util.LspFileToUri(fname)}, range: r})
+  var d: list<dict<any>> = []
+  for lnum in range(line1, line2)
+    var diagsInfo: list<dict<any>> = diag.GetDiagsByLine(bnr, lnum, lspserver)->deepcopy()
+    if lspserver.needOffsetEncoding
+      diagsInfo->map((_, di) => {
+	  lspserver.encodeRange(bnr, di.range)
+	  return di
+	})
+    endif
+    d->extend(diagsInfo)
+  endfor
+  params->extend({context: {diagnostics: d, triggerKind: 1}})
+
+  var reply = lspserver.rpc('textDocument/codeAction', params)
+
+  # Result: (Command | CodeAction)[] | null
+  if reply->empty() || reply.result->empty()
+    # no action can be performed
+    util.WarnMsg('No code action is available')
+    return
+  endif
+
+  DecodeCodeAction(lspserver, reply.result)
+
+  codeaction.ApplyCodeAction(lspserver, reply.result, query)
+enddef
+
+# Request: "textDocument/codeLens"
+# Param: CodeLensParams
+def CodeLens(lspserver: dict<any>, fname: string)
+  # Check whether LSP server supports code lens operation
+  if !lspserver.isCodeLensProvider
+    util.ErrMsg('LSP server does not support code lens operation')
+    return
+  endif
+
+  var params = {textDocument: {uri: util.LspFileToUri(fname)}}
+  var reply = lspserver.rpc('textDocument/codeLens', params)
+  if reply->empty() || reply.result->empty()
+    util.WarnMsg($'No code lens actions found for the current file')
+    return
+  endif
+
+  var bnr = fname->bufnr()
+
+  # Decode the position encoding in all the code lens items
+  if lspserver.needOffsetEncoding
+    reply.result->map((_, codeLensItem) => {
+      lspserver.decodeRange(bnr, codeLensItem.range)
+      return codeLensItem
+    })
+  endif
+
+  codelens.ProcessCodeLens(lspserver, bnr, reply.result)
+enddef
+
+# Request: "codeLens/resolve"
+# Param: CodeLens
+def ResolveCodeLens(lspserver: dict<any>, bnr: number,
+		    codeLens: dict<any>): dict<any>
+  if !lspserver.isCodeLensResolveProvider
+    return {}
+  endif
+
+  if lspserver.needOffsetEncoding
+    lspserver.encodeRange(bnr, codeLens.range)
+  endif
+
+  var reply = lspserver.rpc('codeLens/resolve', codeLens)
+  if reply->empty()
+    return {}
+  endif
+
+  var codeLensItem: dict<any> = reply.result
+
+  # Decode the position encoding in the code lens item
+  if lspserver.needOffsetEncoding
+    lspserver.decodeRange(bnr, codeLensItem.range)
+  endif
+
+  return codeLensItem
+enddef
+
+# List project-wide symbols matching query string
+# Request: "workspace/symbol"
+# Param: WorkspaceSymbolParams
+def WorkspaceQuerySymbols(lspserver: dict<any>, query: string, firstCall: bool, cmdmods: string = '')
+  # Check whether the LSP server supports listing workspace symbols
+  if !lspserver.isWorkspaceSymbolProvider
+    util.ErrMsg('LSP server does not support listing workspace symbols')
+    return
+  endif
+
+  # Param: WorkspaceSymbolParams
+  var param = {
+    query: query
+  }
+  var reply = lspserver.rpc('workspace/symbol', param)
+  if reply->empty() || reply.result->empty()
+    util.WarnMsg($'Symbol "{query}" is not found')
+    return
+  endif
+
+  var symInfo: list<dict<any>> = reply.result
+
+  if lspserver.needOffsetEncoding
+    # Decode the position encoding in all the symbol locations
+    symInfo->map((_, sym) => {
+      if sym->has_key('location')
+	lspserver.decodeLocation(sym.location)
+      endif
+      return sym
+    })
+  endif
+
+  if firstCall && symInfo->len() == 1
+    # If there is only one symbol, then jump to the symbol location
+    var symLoc: dict<any> = symInfo[0]->get('location', {})
+    if !symLoc->empty()
+      symbol.GotoSymbol(lspserver, symLoc, false, cmdmods)
+    endif
+  else
+    symbol.WorkspaceSymbolPopup(lspserver, query, symInfo, cmdmods)
+  endif
+enddef
+
+# Add a workspace folder to the language server.
+def AddWorkspaceFolder(lspserver: dict<any>, dirName: string): void
+  if !lspserver.caps->has_key('workspace')
+	  || !lspserver.caps.workspace->has_key('workspaceFolders')
+	  || !lspserver.caps.workspace.workspaceFolders->has_key('supported')
+	  || !lspserver.caps.workspace.workspaceFolders.supported
+      util.ErrMsg('LSP server does not support workspace folders')
+    return
+  endif
+
+  if lspserver.workspaceFolders->index(dirName) != -1
+    util.ErrMsg($'{dirName} is already part of this workspace')
+    return
+  endif
+
+  # Notification: 'workspace/didChangeWorkspaceFolders'
+  # Params: DidChangeWorkspaceFoldersParams
+  var params = {event: {added: [dirName], removed: []}}
+  lspserver.sendNotification('workspace/didChangeWorkspaceFolders', params)
+
+  lspserver.workspaceFolders->add(dirName)
+enddef
+
+# Remove a workspace folder from the language server.
+def RemoveWorkspaceFolder(lspserver: dict<any>, dirName: string): void
+  if !lspserver.caps->has_key('workspace')
+	  || !lspserver.caps.workspace->has_key('workspaceFolders')
+	  || !lspserver.caps.workspace.workspaceFolders->has_key('supported')
+	  || !lspserver.caps.workspace.workspaceFolders.supported
+      util.ErrMsg('LSP server does not support workspace folders')
+    return
+  endif
+
+  var idx: number = lspserver.workspaceFolders->index(dirName)
+  if idx == -1
+    util.ErrMsg($'{dirName} is not currently part of this workspace')
+    return
+  endif
+
+  # Notification: "workspace/didChangeWorkspaceFolders"
+  # Param: DidChangeWorkspaceFoldersParams
+  var params = {event: {added: [], removed: [dirName]}}
+  lspserver.sendNotification('workspace/didChangeWorkspaceFolders', params)
+
+  lspserver.workspaceFolders->remove(idx)
+enddef
+
+def DecodeSelectionRange(lspserver: dict<any>, bnr: number, selRange: dict<any>)
+  lspserver.decodeRange(bnr, selRange.range)
+  if selRange->has_key('parent')
+    DecodeSelectionRange(lspserver, bnr, selRange.parent)
+  endif
+enddef
+
+# select the text around the current cursor location
+# Request: "textDocument/selectionRange"
+# Param: SelectionRangeParams
+def SelectionRange(lspserver: dict<any>, fname: string)
+  # Check whether LSP server supports selection ranges
+  if !lspserver.isSelectionRangeProvider
+    util.ErrMsg('LSP server does not support selection ranges')
+    return
+  endif
+
+  # clear the previous selection reply
+  lspserver.selection = {}
+
+  # interface SelectionRangeParams
+  # interface TextDocumentIdentifier
+  var param = {
+    textDocument: {
+      uri: util.LspFileToUri(fname)
+    },
+    positions: [lspserver.getPosition(false)]
+  }
+  var reply = lspserver.rpc('textDocument/selectionRange', param)
+
+  if reply->empty() || reply.result->empty()
+    return
+  endif
+
+  # Decode the position encoding in all the selection range items
+  if lspserver.needOffsetEncoding
+    var bnr = fname->bufnr()
+    reply.result->map((_, selItem) => {
+	DecodeSelectionRange(lspserver, bnr, selItem)
+	return selItem
+      })
+  endif
+
+  selection.SelectionStart(lspserver, reply.result)
+enddef
+
+# Expand the previous selection or start a new one
+def SelectionExpand(lspserver: dict<any>)
+  # Check whether LSP server supports selection ranges
+  if !lspserver.isSelectionRangeProvider
+    util.ErrMsg('LSP server does not support selection ranges')
+    return
+  endif
+
+  selection.SelectionModify(lspserver, true)
+enddef
+
+# Shrink the previous selection or start a new one
+def SelectionShrink(lspserver: dict<any>)
+  # Check whether LSP server supports selection ranges
+  if !lspserver.isSelectionRangeProvider
+    util.ErrMsg('LSP server does not support selection ranges')
+    return
+  endif
+
+  selection.SelectionModify(lspserver, false)
+enddef
+
+# fold the entire document
+# Request: "textDocument/foldingRange"
+# Param: FoldingRangeParams
+def FoldRange(lspserver: dict<any>, fname: string)
+  # Check whether LSP server supports fold ranges
+  if !lspserver.isFoldingRangeProvider
+    util.ErrMsg('LSP server does not support folding')
+    return
+  endif
+
+  # interface FoldingRangeParams
+  # interface TextDocumentIdentifier
+  var params = {textDocument: {uri: util.LspFileToUri(fname)}}
+  var reply = lspserver.rpc('textDocument/foldingRange', params)
+  if reply->empty() || reply.result->empty()
+    return
+  endif
+
+  # result: FoldingRange[]
+  var end_lnum: number
+  var last_lnum: number = line('$')
+  for foldRange in reply.result
+    end_lnum = foldRange.endLine + 1
+    if end_lnum < foldRange.startLine + 2
+      end_lnum = foldRange.startLine + 2
+    endif
+    exe $':{foldRange.startLine + 2}, {end_lnum}fold'
+    # Open all the folds, otherwise the subsequently created folds are not
+    # correct.
+    :silent! foldopen!
+  endfor
+
+  if &foldcolumn == 0
+    :setlocal foldcolumn=2
+  endif
+enddef
+
+# process the 'workspace/executeCommand' reply from the LSP server
+# Result: any | null
+def WorkspaceExecuteReply(lspserver: dict<any>, execReply: any)
+  # Nothing to do for the reply
+enddef
+
+# Request the LSP server to execute a command
+# Request: workspace/executeCommand
+# Params: ExecuteCommandParams
+def ExecuteCommand(lspserver: dict<any>, cmd: dict<any>)
+  # Need to check for lspserver.caps.executeCommandProvider?
+  var params: dict<any> = {}
+  params.command = cmd.command
+  if cmd->has_key('arguments')
+    params.arguments = cmd.arguments
+  endif
+
+  lspserver.rpc_a('workspace/executeCommand', params, WorkspaceExecuteReply)
+enddef
+
+# Display the LSP server capabilities (received during the initialization
+# stage).
+def GetCapabilities(lspserver: dict<any>): list<string>
+  var l = []
+  var heading = $"'{lspserver.path}' Language Server Capabilities"
+  var underlines = repeat('=', heading->len())
+  l->extend([heading, underlines])
+  for k in lspserver.caps->keys()->sort()
+    l->add($'{k}: {lspserver.caps[k]->string()}')
+  endfor
+  return l
+enddef
+
+# Display the LSP server initialize request and result
+def GetInitializeRequest(lspserver: dict<any>): list<string>
+  var l = []
+  var heading = $"'{lspserver.path}' Language Server Initialize Request"
+  var underlines = repeat('=', heading->len())
+  l->extend([heading, underlines])
+  if lspserver->has_key('rpcInitializeRequest')
+    for k in lspserver.rpcInitializeRequest->keys()->sort()
+      l->add($'{k}: {lspserver.rpcInitializeRequest[k]->string()}')
+    endfor
+  endif
+  return l
+enddef
+
+# Store a log or trace message received from the language server.
+def AddMessage(lspserver: dict<any>, msgType: string, newMsg: string)
+  # A single message may contain multiple lines separate by newline
+  var msgs = newMsg->split("\n")
+  lspserver.messages->add($'{strftime("%m/%d/%y %T")}: [{msgType}]: {msgs[0]}')
+  lspserver.messages->extend(msgs[1 : ])
+  # Keep only the last 500 messages to reduce the memory usage
+  if lspserver.messages->len() >= 600
+    lspserver.messages = lspserver.messages[-500 : ]
+  endif
+enddef
+
+# Display the log messages received from the LSP server (window/logMessage)
+def GetMessages(lspserver: dict<any>): list<string>
+  if lspserver.messages->empty()
+    return [$'No messages received from "{lspserver.name}" server']
+  endif
+
+  var l = []
+  var heading = $"'{lspserver.path}' Language Server Messages"
+  var underlines = repeat('=', heading->len())
+  l->extend([heading, underlines])
+  l->extend(lspserver.messages)
+  return l
+enddef
+
+# Send a 'textDocument/definition' request to the LSP server to get the
+# location where the symbol under the cursor is defined and return a list of
+# Dicts in a format accepted by the 'tagfunc' option.
+# Returns null if the LSP server doesn't support getting the location of a
+# symbol definition or the symbol is not defined.
+def TagFunc(lspserver: dict<any>, pat: string, flags: string, info: dict<any>): any
+  # Check whether LSP server supports getting the location of a definition
+  if !lspserver.isDefinitionProvider
+    return null
+  endif
+
+  # interface DefinitionParams
+  #   interface TextDocumentPositionParams
+  var reply = lspserver.rpc('textDocument/definition',
+			    lspserver.getTextDocPosition(false))
+  if reply->empty() || reply.result->empty()
+    return null
+  endif
+
+  var taglocations: list<dict<any>>
+  if reply.result->type() == v:t_list
+    taglocations = reply.result
+  else
+    taglocations = [reply.result]
+  endif
+
+  if lspserver.needOffsetEncoding
+    # Decode the position encoding in all the reference locations
+    taglocations->map((_, loc) => {
+      lspserver.decodeLocation(loc)
+      return loc
+    })
+  endif
+
+  return symbol.TagFunc(lspserver, taglocations, pat)
+enddef
+
+# Returns unique ID used for identifying the various servers
+var UniqueServerIdCounter = 0
+def GetUniqueServerId(): number
+  UniqueServerIdCounter = UniqueServerIdCounter + 1
+  return UniqueServerIdCounter
+enddef
+
+export def NewLspServer(serverParams: dict<any>): dict<any>
+  var lspserver: dict<any> = {
+    id: GetUniqueServerId(),
+    name: serverParams.name,
+    path: serverParams.path,
+    args: serverParams.args->deepcopy(),
+    running: false,
+    ready: false,
+    job: v:none,
+    data: '',
+    nextID: 1,
+    caps: {},
+    requests: {},
+    callHierarchyType: '',
+    completionTriggerChars: [],
+    customNotificationHandlers: serverParams.customNotificationHandlers->deepcopy(),
+    customRequestHandlers: serverParams.customRequestHandlers->deepcopy(),
+    debug: serverParams.debug,
+    features: serverParams.features->deepcopy(),
+    forceOffsetEncoding: serverParams.forceOffsetEncoding,
+    initializationOptions: serverParams.initializationOptions->deepcopy(),
+    messages: [],
+    needOffsetEncoding: false,
+    omniCompletePending: false,
+    peekSymbolFilePopup: -1,
+    peekSymbolPopup: -1,
+    processDiagHandler: serverParams.processDiagHandler,
+    rootSearchFiles: serverParams.rootSearch->deepcopy(),
+    runIfSearchFiles: serverParams.runIfSearch->deepcopy(),
+    runUnlessSearchFiles: serverParams.runUnlessSearch->deepcopy(),
+    selection: {},
+    signaturePopup: -1,
+    syncInit: serverParams.syncInit,
+    traceLevel: serverParams.traceLevel,
+    typeHierFilePopup: -1,
+    typeHierPopup: -1,
+    workspaceConfig: serverParams.workspaceConfig->deepcopy(),
+    workspaceSymbolPopup: -1,
+    workspaceSymbolQuery: ''
+  }
+  lspserver.logfile = $'lsp-{lspserver.name}.log'
+  lspserver.errfile = $'lsp-{lspserver.name}.err'
+
+  # Add the LSP server functions
+  lspserver->extend({
+    startServer: function(StartServer, [lspserver]),
+    initServer: function(InitServer, [lspserver]),
+    stopServer: function(StopServer, [lspserver]),
+    shutdownServer: function(ShutdownServer, [lspserver]),
+    exitServer: function(ExitServer, [lspserver]),
+    setTrace: function(SetTrace, [lspserver]),
+    traceLog: function(TraceLog, [lspserver]),
+    errorLog: function(ErrorLog, [lspserver]),
+    nextReqID: function(NextReqID, [lspserver]),
+    createRequest: function(CreateRequest, [lspserver]),
+    createResponse: function(CreateResponse, [lspserver]),
+    sendResponse: function(SendResponse, [lspserver]),
+    sendMessage: function(SendMessage, [lspserver]),
+    sendNotification: function(SendNotification, [lspserver]),
+    rpc: function(Rpc, [lspserver]),
+    rpc_a: function(AsyncRpc, [lspserver]),
+    waitForResponse: function(WaitForResponse, [lspserver]),
+    processReply: function(handlers.ProcessReply, [lspserver]),
+    processNotif: function(handlers.ProcessNotif, [lspserver]),
+    processRequest: function(handlers.ProcessRequest, [lspserver]),
+    processMessages: function(handlers.ProcessMessages, [lspserver]),
+    encodePosition: function(offset.EncodePosition, [lspserver]),
+    decodePosition: function(offset.DecodePosition, [lspserver]),
+    encodeRange: function(offset.EncodeRange, [lspserver]),
+    decodeRange: function(offset.DecodeRange, [lspserver]),
+    encodeLocation: function(offset.EncodeLocation, [lspserver]),
+    decodeLocation: function(offset.DecodeLocation, [lspserver]),
+    getPosition: function(GetPosition, [lspserver]),
+    getTextDocPosition: function(GetTextDocPosition, [lspserver]),
+    featureEnabled: function(FeatureEnabled, [lspserver]),
+    textdocDidOpen: function(TextdocDidOpen, [lspserver]),
+    textdocDidClose: function(TextdocDidClose, [lspserver]),
+    textdocDidChange: function(TextdocDidChange, [lspserver]),
+    sendInitializedNotif: function(SendInitializedNotif, [lspserver]),
+    sendWorkspaceConfig: function(SendWorkspaceConfig, [lspserver]),
+    getCompletion: function(GetCompletion, [lspserver]),
+    resolveCompletion: function(ResolveCompletion, [lspserver]),
+    gotoDefinition: function(GotoDefinition, [lspserver]),
+    gotoDeclaration: function(GotoDeclaration, [lspserver]),
+    gotoTypeDef: function(GotoTypeDef, [lspserver]),
+    gotoImplementation: function(GotoImplementation, [lspserver]),
+    tagFunc: function(TagFunc, [lspserver]),
+    switchSourceHeader: function(SwitchSourceHeader, [lspserver]),
+    showSignature: function(ShowSignature, [lspserver]),
+    didSaveFile: function(DidSaveFile, [lspserver]),
+    hover: function(ShowHoverInfo, [lspserver]),
+    showReferences: function(ShowReferences, [lspserver]),
+    docHighlight: function(DocHighlight, [lspserver]),
+    getDocSymbols: function(GetDocSymbols, [lspserver]),
+    textDocFormat: function(TextDocFormat, [lspserver]),
+    prepareCallHierarchy: function(PrepareCallHierarchy, [lspserver]),
+    incomingCalls: function(IncomingCalls, [lspserver]),
+    getIncomingCalls: function(GetIncomingCalls, [lspserver]),
+    outgoingCalls: function(OutgoingCalls, [lspserver]),
+    getOutgoingCalls: function(GetOutgoingCalls, [lspserver]),
+    inlayHintsShow: function(InlayHintsShow, [lspserver]),
+    typeHierarchy: function(TypeHierarchy, [lspserver]),
+    renameSymbol: function(RenameSymbol, [lspserver]),
+    codeAction: function(CodeAction, [lspserver]),
+    codeLens: function(CodeLens, [lspserver]),
+    resolveCodeLens: function(ResolveCodeLens, [lspserver]),
+    workspaceQuery: function(WorkspaceQuerySymbols, [lspserver]),
+    addWorkspaceFolder: function(AddWorkspaceFolder, [lspserver]),
+    removeWorkspaceFolder: function(RemoveWorkspaceFolder, [lspserver]),
+    selectionRange: function(SelectionRange, [lspserver]),
+    selectionExpand: function(SelectionExpand, [lspserver]),
+    selectionShrink: function(SelectionShrink, [lspserver]),
+    foldRange: function(FoldRange, [lspserver]),
+    executeCommand: function(ExecuteCommand, [lspserver]),
+    workspaceConfigGet: function(WorkspaceConfigGet, [lspserver]),
+    semanticHighlightUpdate: function(SemanticHighlightUpdate, [lspserver]),
+    getCapabilities: function(GetCapabilities, [lspserver]),
+    getInitializeRequest: function(GetInitializeRequest, [lspserver]),
+    addMessage: function(AddMessage, [lspserver]),
+    getMessages: function(GetMessages, [lspserver])
+  })
+
+  return lspserver
+enddef
+
+# vim: tabstop=8 shiftwidth=2 softtabstop=2
diff --git a/vim/pack/downloads/opt/lsp/autoload/lsp/markdown.vim b/vim/pack/downloads/opt/lsp/autoload/lsp/markdown.vim
new file mode 100644
index 0000000..fd73cee
--- /dev/null
+++ b/vim/pack/downloads/opt/lsp/autoload/lsp/markdown.vim
@@ -0,0 +1,757 @@
+vim9script
+
+# Markdown parser
+# Refer to https://github.github.com/gfm/
+# for the GitHub Flavored Markdown specification.
+
+# TODO: different highlight for different heading level
+# TODO: links
+# TODO: pretty table
+
+
+# Container blocks
+var block_quote = '^ \{,3\}\zs> \='
+var list_marker = '[-+*]\|[0-9]\{1,9}[.)]'
+var list_item = $'^\%({list_marker}\)\ze\s*$\|^ \{{,3}}\zs\%({list_marker}\) \{{1,4}}\ze\S\|^ \{{,3}}\zs\%({list_marker}\) \{{5}}\ze\s*\S'
+# pattern to match list items
+export var list_pattern = $'^ *\%({list_marker}\) *'
+
+
+# Leaf blocks
+var blank_line = '^\s*$'
+var thematic_break = '^ \{,3\}\([-_*]\)\%(\s*\1\)\{2,\}\s*$'
+var code_fence = '^ \{,3\}\(`\{3,\}\|\~\{3,\}\)\s*\(\S*\)'
+var code_indent = '^ \{4\}\zs\s*\S.*'
+var paragraph = '^\s*\zs\S.\{-}\s*\ze$'
+
+var atx_heading = '^ \{,3}\zs\(#\{1,6}\) \s*\(.\{-}\)\s*\ze\%( #\{1,}\s*\)\=$'
+var setext_heading = '^ \{,3}\zs\%(=\{1,}\|-\{1,}\)\ze *$'
+var setext_heading_level = {"=": 1, "-": 2}
+
+var table_delimiter = '^|\=\zs *:\=-\{1,}:\= *\%(| *:\=-\{1,}:\= *\)*\ze|\=$'
+
+var punctuation = "[!\"#$%&'()*+,-./:;<=>?@[\\\\\\\]^_`{|}~]"
+
+# Setting text properties
+highlight LspBold term=bold cterm=bold gui=bold
+highlight LspItalic term=italic cterm=italic gui=italic
+highlight LspStrikeThrough term=strikethrough cterm=strikethrough gui=strikethrough
+prop_type_add('LspMarkdownBold', {highlight: 'LspBold'})
+prop_type_add('LspMarkdownItalic', {highlight: 'LspItalic'})
+prop_type_add('LspMarkdownStrikeThrough', {highlight: 'LspStrikeThrough'})
+prop_type_add('LspMarkdownHeading', {highlight: 'Function'})
+prop_type_add('LspMarkdownCode', {highlight: 'PreProc'})
+prop_type_add('LspMarkdownCodeBlock', {highlight: 'PreProc'})
+prop_type_add('LspMarkdownListMarker', {highlight: 'Special'})
+prop_type_add('LspMarkdownTableHeader', {highlight: 'Label'})
+prop_type_add('LspMarkdownTableMarker', {highlight: 'Special'})
+
+
+def GetMarkerProp(marker: string, col: number, ...opt: list<any>): dict<any>
+  if marker == 'list_item'
+    return {
+      type: 'LspMarkdownListMarker',
+      col: col,
+      length: opt[0]
+    }
+  elseif marker == 'code_block'
+    return {
+      type: 'LspMarkdownCodeBlock',
+      col: col,
+      end_lnum: opt[0],
+      end_col: opt[1]
+    }
+  elseif marker == 'heading'
+    return {
+      type: 'LspMarkdownHeading',
+      col: col,
+      length: opt[0]
+    }
+  elseif marker == 'table_header'
+    return {
+      type: 'LspMarkdownTableHeader',
+      col: col,
+      length: opt[0]
+    }
+  elseif marker == 'table_sep'
+    return {
+      type: 'LspMarkdownTableMarker',
+      col: col,
+      length: opt[0]
+    }
+  elseif marker == 'code_span'
+    return {
+      type: 'LspMarkdownCode',
+      col: col,
+      length: opt[0]
+    }
+  elseif marker == 'emphasis'
+    return {
+      type: 'LspMarkdownItalic',
+      col: col,
+      length: opt[0]
+    }
+  elseif marker == 'strong'
+    return {
+      type: 'LspMarkdownBold',
+      col: col,
+      length: opt[0]
+    }
+  elseif marker == 'strikethrough'
+    return {
+      type: 'LspMarkdownStrikeThrough',
+      col: col,
+      length: opt[0]
+    }
+  endif
+  return {}
+enddef
+
+def GetCodeSpans(text: string): list<dict<any>>
+  var code_spans = []
+  var pos = 0
+  while pos < text->len()
+    var backtick = text->matchstrpos('\\*`', pos)
+    if backtick[1] < 0
+      break
+    endif
+    if backtick[0]->len() % 2 == 0
+      # escaped backtick
+      pos = backtick[2]
+      continue
+    endif
+    pos = backtick[2] - 1
+    var code_span = text->matchstrpos('^\(`\+\)`\@!.\{-}`\@1<!\1`\@!', pos)
+    if code_span[1] < 0
+      break
+    endif
+    var code_text = text->matchstrpos('^\(`\+\)\%(\zs \+\ze\|\([ \n]\=\)\zs.\{-}\S.\{-}\ze\2\)`\@1<!\1`\@!', pos)
+    code_spans->add({
+	marker: '`',
+	start: [code_span[1], code_text[1]],
+	end: [code_text[2], code_span[2]]
+      })
+    pos = code_span[2]
+  endwhile
+  return code_spans
+enddef
+
+def Unescape(text: string, block_marker: string = ""): string
+  if block_marker == '`'
+    # line breaks do not occur inside code spans
+    return text->substitute('\n', ' ', 'g')
+  endif
+  # use 2 spaces instead of \ for hard line break
+  var result = text->substitute('\\\@<!\(\(\\\\\)*\)\\\n', '\1  \n', 'g')
+  # change soft line breaks
+  result = result->substitute(' \@<! \=\n', ' ', 'g')
+  # change hard line breaks
+  result = result->substitute(' \{2,}\n', '\n', 'g')
+  # replace non-breaking spaces with spaces
+  result = result->substitute('&nbsp;', ' ', 'g')
+  return result->substitute($'\\\({punctuation}\)', '\1', 'g')
+enddef
+
+def GetNextInlineDelimiter(text: string, start_pos: number, end_pos: number): dict<any>
+  var pos = start_pos
+  while pos < text->len()
+    # search the first delimiter char
+    var delimiter = text->matchstrpos('\\*[_*~]', pos)
+    if delimiter[1] < 0 || delimiter[1] > end_pos
+      return {}
+    endif
+    if delimiter[0]->len() % 2 == 0
+      # escaped delimiter char
+      pos = delimiter[2]
+      continue
+    endif
+    pos = delimiter[2] - 1
+    var delimiter_run = text->matchstrpos(
+	    $'{delimiter[0][-1]->substitute("\\([*~]\\)", "\\\\\\1", "g")}\+',
+	    pos)
+    if delimiter_run[0][0] == '~' && delimiter_run[0]->len() > 2
+      pos = delimiter_run[2]
+      continue
+    endif
+    var add_char = ''
+    if pos > 0
+      pos -= 1
+      add_char = '.'
+    endif
+    var delim_regex = delimiter_run[0]->substitute('\([*~]\)', '\\\1', 'g')
+    var is_left = text->match($'^{add_char}{delim_regex}\%(\s\|$\|{punctuation}\)\@!\|^{add_char}\%(\s\|^\|{punctuation}\)\@1<={delim_regex}{punctuation}', pos) >= 0
+    var is_right = text->match($'^{add_char}\%(\s\|^\|{punctuation}\)\@1<!{delim_regex}\|^{add_char}{punctuation}\@1<={delim_regex}\%(\s\|$\|{punctuation}\)', pos) >= 0
+    if !is_left && ! is_right
+      pos = delimiter_run[2]
+      continue
+    endif
+    if delimiter_run[0][0] == '_'
+	&& text->match($'^\w{delimiter_run[0]}\w', pos) >= 0
+      # intraword emphasis is disallowed
+      pos = delimiter_run[2]
+      continue
+    endif
+    return {
+      marker: delimiter_run[0],
+      start: [delimiter_run[1], delimiter_run[2]],
+      left: is_left,
+      right: is_right
+    }
+  endwhile
+  return {}
+enddef
+
+def GetNextInlineBlock(text: string, blocks: list<any>, rel_pos: number): dict<any>
+  var result = {
+    text: '',
+    props: []
+  }
+  var cur = blocks->remove(0)
+  var pos = cur.start[1]
+  while blocks->len() > 0 && cur.end[0] >= blocks[0].start[0]
+    result.text ..= Unescape(text->strpart(pos, blocks[0].start[0] - pos), cur.marker[0])
+    # get nested block
+    var part = GetNextInlineBlock(text, blocks, rel_pos + result.text->len())
+    result.text ..= part.text
+    result.props += part.props
+    pos = part.end_pos
+  endwhile
+  result.text ..= Unescape(text->strpart(pos, cur.end[0] - pos), cur.marker[0])
+  # add props for current inline block
+  var prop_type = {
+    '`':  'code_span',
+    '_':  'emphasis',
+    '__': 'strong',
+    '*':  'emphasis',
+    '**': 'strong',
+    '~':  'strikethrough',
+    '~~': 'strikethrough'
+  }
+  result.props->insert(GetMarkerProp(prop_type[cur.marker],
+				      rel_pos + 1,
+				      result.text->len()))
+  result->extend({'end_pos': cur.end[1]})
+  return result
+enddef
+
+def ParseInlines(text: string, rel_pos: number = 0): dict<any>
+  var formatted = {
+    text: '',
+    props: []
+  }
+  var code_spans = GetCodeSpans(text)
+
+  var pos = 0
+  var seq = []
+  # search all emphasis
+  while pos < text->len()
+    var code_pos: list<number>
+    if code_spans->len() > 0
+      code_pos = [code_spans[0].start[0], code_spans[0].end[1]]
+      if pos >= code_pos[0]
+	pos = code_pos[1]
+	seq->add(code_spans->remove(0))
+	continue
+      endif
+    else
+      code_pos = [text->len(), text->len()]
+    endif
+    var delimiter = GetNextInlineDelimiter(text, pos, code_pos[0])
+    if delimiter->empty()
+      pos = code_pos[1]
+      continue
+    endif
+    if delimiter.right
+      var idx = seq->len() - 1
+      while idx >= 0
+	if delimiter.marker[0] != seq[idx].marker[0]
+	    || seq[idx]->has_key('end')
+	  idx -= 1
+	  continue
+	endif
+	if delimiter.left || seq[idx].right
+	  # check the sum rule
+	  if (delimiter.marker->len() + seq[idx].marker->len()) % 3 == 0
+	      && (delimiter.marker->len() % 3 > 0
+		  || seq[idx].marker->len() % 3 > 0)
+	    # not valid condition
+	    idx -= 1
+	    continue
+	  endif
+	endif
+	var marker_len = min([delimiter.marker->len(),
+			      seq[idx].marker->len(), 2])
+	if seq[idx].marker->len() > marker_len
+	  var new_delim = {
+	    marker: delimiter.marker[0]->repeat(marker_len),
+	    start: [seq[idx].start[1] - marker_len, seq[idx].start[1]],
+	    left: true,
+	    right: false
+	  }
+	  seq[idx].marker = seq[idx].marker[: -1 - marker_len]
+	  seq[idx].start[1] -= marker_len
+	  seq[idx].right = false
+	  idx += 1
+	  seq->insert(new_delim, idx)
+	endif
+	seq[idx]->extend({
+		    end: [delimiter.start[0],
+			  delimiter.start[0] + marker_len]})
+        # close all overlapped emphasis spans not closed
+        for i in range(seq->len() - 1, idx + 1, -1)
+          if !seq[i]->has_key('end')
+            seq->remove(i)
+          endif
+        endfor
+	if delimiter.marker->len() > marker_len
+	  delimiter.start[0] += marker_len
+	else
+	  delimiter.left = false
+	  break
+	endif
+	idx -= 1
+      endwhile
+    endif
+    if delimiter.left
+      seq->add(delimiter)
+    endif
+    pos = delimiter.start[1]
+  endwhile
+  while code_spans->len() > 0
+    seq->add(code_spans->remove(0))
+  endwhile
+  # remove all not closed delimiters
+  for i in range(seq->len() - 1, 0, -1)
+    if !seq[i]->has_key('end')
+      seq->remove(i)
+    endif
+  endfor
+
+  # compose final text
+  pos = 0
+  while seq->len() > 0
+    if pos < seq[0].start[0]
+      formatted.text ..= Unescape(text->strpart(pos, seq[0].start[0] - pos))
+      pos = seq[0].start[0]
+    endif
+    var inline = GetNextInlineBlock(text, seq,
+				    rel_pos + formatted.text->len())
+    formatted.text ..= inline.text
+    formatted.props += inline.props
+    pos = inline.end_pos
+  endwhile
+  if pos < text->len()
+    formatted.text ..= Unescape(text->strpart(pos))
+  endif
+  return formatted
+enddef
+
+# new open container block
+def CreateContainerBlock(match: list<any>, start_lnum: number): dict<any>
+  if match[0][0] == '>'
+    return {
+      type: 'quote_block',
+      lnum: start_lnum,
+      indent: 0
+    }
+  else
+    return {
+      type: 'list_item',
+      lnum: start_lnum,
+      marker: $' {match[0]->matchstr("\\S\\+")} ',
+      indent: match[2]
+    }
+  endif
+enddef
+
+# new open leaf block
+def CreateLeafBlock(block_type: string, line: string, ...opt: list<any>): dict<any>
+  if block_type == 'fenced_code'
+    var token = line->matchlist(code_fence)
+    return {
+      type: block_type,
+      fence: token[1],
+      language: token[2],
+      text: []
+    }
+  elseif block_type == 'indented_code'
+    return {
+      type: block_type,
+      text: [line->matchstr(code_indent)]
+    }
+  elseif block_type == 'paragraph'
+    return {
+      type: block_type,
+      text: [line->matchstr(paragraph)]
+    }
+  elseif block_type == 'heading'
+    return {
+      type: block_type,
+      level: opt[0],
+      text: line
+    }
+  elseif block_type == 'table'
+    return {
+      type: block_type,
+      header: line,
+      delimiter: opt[0],
+      text: []
+    }
+  endif
+  return {}
+enddef
+
+def NeedBlankLine(prev: string, cur: string): bool
+  if prev == 'hr' || cur == 'hr'
+    return false
+  elseif prev == 'heading' || cur == 'heading'
+    return true
+  elseif prev == 'paragraph' && cur == 'paragraph'
+    return true
+  elseif prev != cur
+    return true
+  endif
+  return false
+enddef
+
+def SplitLine(line: dict<any>, indent: number = 0): list<dict<any>>
+  var lines: list<dict<any>> = []
+  var tokens: list<string> = line.text->split("\n", true)
+  if tokens->len() == 1
+    lines->add(line)
+    return lines
+  endif
+  var props: list<dict<any>> = line.props
+  for cur_text in tokens
+    var cur_props: list<dict<any>> = []
+    var next_props: list<dict<any>> = []
+    var length: number = cur_text->len()
+    for prop in props
+      if prop.col + prop.length - 1 <= length
+        cur_props->add(prop)
+      elseif prop.col > length
+        prop.col -= length + 1
+        next_props->add(prop)
+      else
+        var cur_length: number = length - prop.col + 1
+        cur_props->add({
+          type: prop.type,
+          col: prop.col,
+          length: cur_length
+        })
+        prop.col = 1
+        prop.length -= cur_length + 1
+        next_props->add(prop)
+      endif
+    endfor
+    lines->add({
+      text: cur_text,
+      props: cur_props
+    })
+    props = next_props
+  endfor
+  return lines
+enddef
+
+var last_block: string = ''
+
+def CloseBlocks(document: dict<list<any>>, blocks: list<dict<any>>, start: number = 0): void
+  if start >= blocks->len()
+    return
+  endif
+  var line: dict<any> = {
+    text: '',
+    props: []
+  }
+  if !document.content->empty() && NeedBlankLine(last_block, blocks[0].type)
+    document.content->add({text: '', props: []})
+  endif
+  last_block = blocks[0].type
+
+  for i in start->range()
+    if blocks[i]->has_key('marker')
+      if blocks[i].marker =~ '\S'
+	line.props->add(GetMarkerProp('list_item',
+				      line.text->len() + 1,
+				      blocks[i].marker->len()))
+	line.text ..= blocks[i].marker
+	blocks[i].marker = ' '->repeat(blocks[i].marker->len())
+      else
+	line.text ..= blocks[i].marker
+      endif
+    endif
+  endfor
+  for block in blocks->remove(start, -1)
+    if block.type =~ 'quote_block\|list_item'
+      if block->has_key('marker')
+	if block.marker =~ '\S'
+	  line.props->add(GetMarkerProp('list_item',
+					line.text->len() + 1,
+					block.marker->len()))
+	  line.text ..= block.marker
+	  block.marker = ' '->repeat(block.marker->len())
+	else
+	  line.text ..= block.marker
+	endif
+      endif
+    else
+      # leaf block
+      if block.type =~ '_code'
+	if block.type == 'indented_code'
+	  while !block.text->empty() && block.text[0] !~ '\S'
+	    block.text->remove(0)
+	  endwhile
+	  while !block.text->empty() && block.text[-1] !~ '\S'
+	    block.text->remove(-1)
+	  endwhile
+	endif
+	if !block.text->empty()
+	  var indent = ' '->repeat(line.text->len())
+	  var max_len = mapnew(block.text, (_, l) => l->len())->max()
+	  var text = block.text->remove(0)
+	  line.text ..= text
+	  document.content->add(line)
+	  var startline = document.content->len()
+	  for l in block.text
+	    document.content->add({text: indent .. l})
+	  endfor
+	  if block->has_key('language')
+	      && !globpath(&rtp, $'syntax/{block.language}.vim')->empty()
+	    document.syntax->add({lang: block.language,
+				  start: $'\%{startline}l\%{indent->len() + 1}c',
+				  end: $'\%{document.content->len()}l$'})
+	  else
+	    line.props->add(GetMarkerProp('code_block',
+					  indent->len() + 1,
+					  document.content->len(),
+					  indent->len() + max_len + 1))
+	  endif
+	endif
+      elseif block.type == 'heading'
+	line.props->add(GetMarkerProp('heading',
+				      line.text->len() + 1,
+				      block.text->len(),
+				      block.level))
+	var format = ParseInlines(block.text, line.text->len())
+	line.text ..= format.text
+	line.props += format.props
+	document.content += SplitLine(line)
+      elseif block.type == 'table'
+	var indent = line.text
+	var head = block.header->split('\\\@1<!|')
+	var col1 = head->remove(0)
+	var format = ParseInlines(col1, line.text->len())
+	line.props->add(GetMarkerProp('table_header',
+				      line.text->len() + 1,
+				      format.text->len()))
+	line.text ..= format.text
+	line.props += format.props
+	for colx in head
+	  format = ParseInlines(colx, line.text->len() + 1)
+	  line.props->add(GetMarkerProp('table_sep', line.text->len() + 1, 1))
+	  line.props->add(GetMarkerProp('table_header',
+					line.text->len() + 2,
+					format.text->len()))
+	  line.text ..= $'|{format.text}'
+	  line.props += format.props
+	endfor
+	document.content->add(line)
+	var data = {
+	  text: indent .. block.delimiter,
+	  props: [GetMarkerProp('table_sep',
+				indent->len() + 1,
+				block.delimiter->len())]
+	}
+	document.content->add(data)
+	for row in block.text
+	  data = {
+	    text: indent,
+	    props: []
+	  }
+	  var cell = row->split('\\\@1<!|')
+	  col1 = cell->remove(0)
+	  format = ParseInlines(col1, data.text->len())
+	  data.text ..= format.text
+	  data.props += format.props
+	  for colx in cell
+	    format = ParseInlines(colx, data.text->len() + 1)
+	    data.props->add(GetMarkerProp('table_sep',
+					  data.text->len() + 1,
+					  1))
+	    data.text ..= $'|{format.text}'
+	    data.props += format.props
+	  endfor
+	  document.content->add(data)
+	endfor
+      elseif block.type == 'paragraph'
+	var indent = line.text->len()
+	var format = ParseInlines(block.text->join("\n")->substitute('\s\+$', '', ''), indent)
+	line.text ..= format.text
+	line.props += format.props
+	document.content += SplitLine(line, indent)
+      endif
+    endif
+  endfor
+enddef
+
+def ExpandTabs(line: string): string
+  var block_marker = line->matchstrpos($'^ \{{,3}}>[ \t]\+\|^[ \t]*\%({list_marker}\)\=[ \t]*')
+  if block_marker[0]->match('\t') < 0
+    return line
+  endif
+  var begin: string = ""
+  for char in block_marker[0]
+    if char == '	'
+      begin ..= ' '->repeat(4 - (begin->len() % 4))
+    else
+      begin ..= char
+    endif
+  endfor
+  return begin .. line[block_marker[2] :]
+enddef
+
+export def ParseMarkdown(data: list<string>, width: number = 80): dict<list<any>>
+  var document: dict<list<any>> = {content: [], syntax: []}
+  var open_blocks: list<dict<any>> = []
+
+  for l in data
+    var line: string = ExpandTabs(l)
+    var cur = 0
+
+    # for each open block check if current line continue it
+    while cur < open_blocks->len()
+      if open_blocks[cur].type == 'quote_block'
+	var marker = line->matchstrpos(block_quote)
+	if marker[1] == -1
+	  break
+	endif
+	line = line->strpart(marker[2])
+      elseif open_blocks[cur].type == 'list_item'
+	var marker = line->matchstrpos($'^ \{{{open_blocks[cur].indent}}}')
+	if marker[1] == -1
+	  break
+	endif
+	line = line->strpart(marker[2])
+      elseif open_blocks[cur].type == 'fenced_code'
+	if line =~ $'^ \{{,3}}{open_blocks[cur].fence}{open_blocks[cur].fence[0]}* *$'
+	  CloseBlocks(document, open_blocks, cur)
+	else
+	  open_blocks[cur].text->add(line)
+	endif
+	cur = -1
+	break
+      elseif open_blocks[cur].type == 'indented_code'
+	var marker = line->matchstrpos(code_indent)
+	if marker[1] >= 0
+	  open_blocks[cur].text->add(marker[0])
+	  cur = -1
+	endif
+	break
+      elseif open_blocks[cur].type == 'paragraph'
+	if line =~ setext_heading
+	  var marker = line->matchstrpos(setext_heading)
+	  open_blocks->add(CreateLeafBlock(
+				  'heading',
+				  open_blocks->remove(cur).text->join("\n")->substitute('\s\+$', '', ''),
+				  setext_heading_level[marker[0][0]]))
+	  CloseBlocks(document, open_blocks, cur)
+	  cur = -1
+	elseif open_blocks[cur].text->len() == 1
+	  # may be a table
+	  var marker = line->matchstr(table_delimiter)
+	  if !marker->empty()
+	    if open_blocks[cur].text[0]->split('\\\@1<!|')->len() == marker->split('|')->len()
+	      open_blocks->add(CreateLeafBlock(
+				  'table',
+				  open_blocks->remove(cur).text[0],
+				  marker))
+	      cur = -1
+	    endif
+	  endif
+	endif
+	break
+      endif
+      cur += 1
+    endwhile
+
+    if cur < 0
+      # the whole line is already consumed
+      continue
+    endif
+
+    # a thematic break close all previous blocks
+    if line =~ thematic_break
+      CloseBlocks(document, open_blocks)
+      if &g:encoding == 'utf-8'
+	document.content->add({text: "\u2500"->repeat(width)})
+      else
+	document.content->add({text: '-'->repeat(width)})
+      endif
+      last_block = 'hr'
+      continue
+    endif
+
+    # check for new container blocks
+    while true
+      var block = line->matchstrpos($'{block_quote}\|{list_item}')
+      if block[1] < 0
+	break
+      endif
+      # close unmatched blocks
+      CloseBlocks(document, open_blocks, cur)
+      # start a new block
+      open_blocks->add(CreateContainerBlock(block, document->len()))
+      cur = open_blocks->len()
+      line = line->strpart(block[2])
+    endwhile
+
+    # check for leaf block
+    if line =~ code_fence
+      CloseBlocks(document, open_blocks, cur)
+      open_blocks->add(CreateLeafBlock('fenced_code', line))
+    elseif line =~ blank_line
+      if open_blocks->empty()
+	continue
+      endif
+      if open_blocks[-1].type == 'paragraph'
+	CloseBlocks(document, open_blocks, min([cur, open_blocks->len() - 1]))
+      elseif open_blocks[-1].type == 'table'
+	CloseBlocks(document, open_blocks, open_blocks->len() - 1)
+      elseif open_blocks[-1].type =~ '_code'
+	open_blocks[-1].text->add(line)
+      endif
+    elseif line =~ code_indent
+      if open_blocks->empty()
+	open_blocks->add(CreateLeafBlock('indented_code', line))
+      elseif open_blocks[-1].type =~ '_code'
+	open_blocks[-1].text->add(line->matchstr(code_indent))
+      elseif open_blocks[-1].type == 'paragraph'
+	open_blocks[-1].text->add(line->matchstr(paragraph))
+      else
+        CloseBlocks(document, open_blocks, cur)
+	open_blocks->add(CreateLeafBlock('indented_code', line))
+      endif
+    elseif line =~ atx_heading
+      CloseBlocks(document, open_blocks, cur)
+      var token = line->matchlist(atx_heading)
+      open_blocks->add(CreateLeafBlock('heading', token[2], token[1]->len()))
+      CloseBlocks(document, open_blocks, cur)
+    elseif !open_blocks->empty()
+      if open_blocks[-1].type == 'table'
+	open_blocks[-1].text->add(line)
+      elseif open_blocks[-1].type == 'paragraph'
+	open_blocks[-1].text->add(line->matchstr(paragraph))
+      else
+        CloseBlocks(document, open_blocks, cur)
+        open_blocks->add(CreateLeafBlock('paragraph', line))
+      endif
+    else
+      open_blocks->add(CreateLeafBlock('paragraph', line))
+    endif
+  endfor
+
+  CloseBlocks(document, open_blocks)
+  return document
+enddef
+
+# vim: tabstop=8 shiftwidth=2 softtabstop=2
diff --git a/vim/pack/downloads/opt/lsp/autoload/lsp/offset.vim b/vim/pack/downloads/opt/lsp/autoload/lsp/offset.vim
new file mode 100644
index 0000000..699964e
--- /dev/null
+++ b/vim/pack/downloads/opt/lsp/autoload/lsp/offset.vim
@@ -0,0 +1,168 @@
+vim9script
+
+import './util.vim'
+
+# Functions for encoding and decoding the LSP position offsets.  Language
+# servers support either UTF-8 or UTF-16 or UTF-32 position offsets.  The
+# character related Vim functions use the UTF-32 position offset.  The
+# encoding used is negotiated during the language server initialization.
+
+# Encode the UTF-32 character offset in the LSP position "pos" to the encoding
+# negotiated with the language server.
+#
+# Modifies in-place the UTF-32 offset in pos.character to a UTF-8 or UTF-16 or
+# UTF-32 offset.
+export def EncodePosition(lspserver: dict<any>, bnr: number, pos: dict<number>)
+  if has('patch-9.0.1629')
+    if lspserver.posEncoding == 32 || bnr <= 0
+      # LSP client plugin also uses utf-32 encoding
+      return
+    endif
+
+    :silent! bnr->bufload()
+    var text = bnr->getbufline(pos.line + 1)->get(0, '')
+    if text->empty()
+      return
+    endif
+
+    if lspserver.posEncoding == 16
+      pos.character = text->utf16idx(pos.character, true, true)
+    else
+      pos.character = text->byteidxcomp(pos.character)
+    endif
+  endif
+enddef
+
+# Decode the character offset in the LSP position "pos" using the encoding
+# negotiated with the language server to a UTF-32 offset.
+#
+# Modifies in-place the UTF-8 or UTF-16 or UTF-32 offset in pos.character to a
+# UTF-32 offset.
+export def DecodePosition(lspserver: dict<any>, bnr: number, pos: dict<number>)
+  if has('patch-9.0.1629')
+    if lspserver.posEncoding == 32 || bnr <= 0
+      # LSP client plugin also uses utf-32 encoding
+      return
+    endif
+
+    :silent! bnr->bufload()
+    var text = bnr->getbufline(pos.line + 1)->get(0, '')
+    # If the line is empty then don't decode the character position.
+    if text->empty()
+      return
+    endif
+
+    # If the character position is out-of-bounds, then don't decode the
+    # character position.
+    var textLen = 0
+    if lspserver.posEncoding == 16
+      textLen = text->strutf16len(true)
+    else
+      textLen = text->strlen()
+    endif
+
+    if pos.character > textLen
+      return
+    endif
+
+    if pos.character == textLen
+      pos.character = text->strchars()
+    else
+      if lspserver.posEncoding == 16
+	pos.character = text->charidx(pos.character, true, true)
+      else
+	pos.character = text->charidx(pos.character, true)
+      endif
+    endif
+  endif
+enddef
+
+# Encode the start and end UTF-32 character offsets in the LSP range "range"
+# to the encoding negotiated with the language server.
+#
+# Modifies in-place the UTF-32 offset in range.start.character and
+# range.end.character to a UTF-8 or UTF-16 or UTF-32 offset.
+export def EncodeRange(lspserver: dict<any>, bnr: number,
+		       range: dict<dict<number>>)
+  if has('patch-9.0.1629')
+    if lspserver.posEncoding == 32
+      return
+    endif
+
+    EncodePosition(lspserver, bnr, range.start)
+    EncodePosition(lspserver, bnr, range.end)
+  endif
+enddef
+
+# Decode the start and end character offsets in the LSP range "range" to
+# UTF-32 offsets.
+#
+# Modifies in-place the offset value in range.start.character and
+# range.end.character to a UTF-32 offset.
+export def DecodeRange(lspserver: dict<any>, bnr: number,
+		       range: dict<dict<number>>)
+  if has('patch-9.0.1629')
+    if lspserver.posEncoding == 32
+      return
+    endif
+
+    DecodePosition(lspserver, bnr, range.start)
+    DecodePosition(lspserver, bnr, range.end)
+  endif
+enddef
+
+# Encode the range in the LSP position "location" to the encoding negotiated
+# with the language server.
+#
+# Modifies in-place the UTF-32 offset in location.range to a UTF-8 or UTF-16
+# or UTF-32 offset.
+export def EncodeLocation(lspserver: dict<any>, location: dict<any>)
+  if has('patch-9.0.1629')
+    if lspserver.posEncoding == 32
+      return
+    endif
+
+    var bnr = 0
+    if location->has_key('targetUri')
+      # LocationLink
+      bnr = util.LspUriToBufnr(location.targetUri)
+      if bnr > 0
+	# We use only the "targetSelectionRange" item.  The
+	# "originSelectionRange" and the "targetRange" items are not used.
+	lspserver.encodeRange(bnr, location.targetSelectionRange)
+      endif
+    else
+      # Location
+      bnr = util.LspUriToBufnr(location.uri)
+      if bnr > 0
+	lspserver.encodeRange(bnr, location.range)
+      endif
+    endif
+  endif
+enddef
+
+# Decode the range in the LSP location "location" to UTF-32.
+#
+# Modifies in-place the offset value in location.range to a UTF-32 offset.
+export def DecodeLocation(lspserver: dict<any>, location: dict<any>)
+  if has('patch-9.0.1629')
+    if lspserver.posEncoding == 32
+      return
+    endif
+
+    var bnr = 0
+    if location->has_key('targetUri')
+      # LocationLink
+      bnr = util.LspUriToBufnr(location.targetUri)
+      # We use only the "targetSelectionRange" item.  The
+      # "originSelectionRange" and the "targetRange" items are not used.
+      lspserver.decodeRange(bnr, location.targetSelectionRange)
+    else
+      # Location
+      bnr = util.LspUriToBufnr(location.uri)
+      lspserver.decodeRange(bnr, location.range)
+    endif
+  endif
+enddef
+
+# vim: tabstop=8 shiftwidth=2 softtabstop=2
diff --git a/vim/pack/downloads/opt/lsp/autoload/lsp/options.vim b/vim/pack/downloads/opt/lsp/autoload/lsp/options.vim
new file mode 100644
index 0000000..50697a3
--- /dev/null
+++ b/vim/pack/downloads/opt/lsp/autoload/lsp/options.vim
@@ -0,0 +1,179 @@
+vim9script
+
+export const COMPLETIONMATCHER_CASE = 1
+export const COMPLETIONMATCHER_ICASE = 2
+export const COMPLETIONMATCHER_FUZZY = 3
+
+# LSP plugin options
+# User can override these by calling the OptionsSet() function.
+export var lspOptions: dict<any> = {
+  # Enable ale diagnostics support.
+  # If true, diagnostics will be sent to ale, which will be responsible for
+  # showing them.
+  aleSupport: false,
+
+  # In insert mode, complete the current symbol automatically
+  # Otherwise, use omni-completion
+  autoComplete: true,
+
+  # In normal mode, highlight the current symbol automatically
+  autoHighlight: false,
+
+  # Automatically highlight diagnostics messages from LSP server
+  autoHighlightDiags: true,
+
+  # Automatically populate the location list with new diagnostics
+  autoPopulateDiags: false,
+
+  # icase | fuzzy | case match for language servers that replies with a full
+  # list of completion items
+  completionMatcher: 'case',
+
+  # Due to a bug in the earlier versions of Vim, cannot use the
+  # COMPLETIONMATCHER_CASE constant here for initialization.
+  completionMatcherValue: 1,
+
+  # diagnostics signs options
+  diagSignErrorText: 'E>',
+  diagSignHintText: 'H>',
+  diagSignInfoText: 'I>',
+  diagSignWarningText: 'W>',
+
+  # In insert mode, echo the current symbol signature in the status line
+  # instead of showing it in a popup
+  echoSignature: false,
+
+  # hide disabled code actions
+  hideDisabledCodeActions: false,
+
+  # Highlight diagnostics inline
+  highlightDiagInline: true,
+
+  # Show the symbol documentation in the preview window instead of in a popup
+  hoverInPreview: false,
+
+  # Don't print message when a configured language server is missing.
+  ignoreMissingServer: false,
+
+  # Focus on the location list window after ":LspDiag show"
+  keepFocusInDiags: true,
+
+  # Focus on the location list window after LspShowReferences
+  keepFocusInReferences: true,
+
+  # If true, apply the LSP server supplied text edits after a completion.
+  # If a snippet plugin is going to apply the text edits, then set this to
+  # false to avoid applying the text edits twice.
+  completionTextEdit: true,
+
+  # Alignment of virtual diagnostic text, when showDiagWithVirtualText is true
+  # Allowed values: 'above' | 'below' | 'after' (default is 'above')
+  diagVirtualTextAlign: 'above',
+
+  # Wrapping of virtual diagnostic text, when showDiagWithVirtualText is true.
+  # Allowed valuse: 'default' | 'truncate' | 'wrap' (default is 'default')
+  diagVirtualTextWrap: 'default',
+
+  # Suppress adding a new line on completion selection with <CR>
+  noNewlineInCompletion: false,
+
+  # Omni-completion support.  To keep backward compatibility, this option is
+  # set to null by default instead of false.
+  omniComplete: null,
+
+  # Open outline window on right side
+  outlineOnRight: false,
+
+  # Outline window size
+  outlineWinSize: 20,
+
+  # Enable semantic highlighting
+  semanticHighlight: false,
+
+  # Show diagnostic text in a balloon when the mouse is over the diagnostic
+  showDiagInBalloon: true,
+
+  # Make diagnostics show in a popup instead of echoing
+  showDiagInPopup: true,
+
+  # Suppress diagnostic hover from appearing when the mouse is over the line
+  # Show a diagnostic message on a status line
+  showDiagOnStatusLine: false,
+
+  # Show a diagnostic messages using signs
+  showDiagWithSign: true,
+
+  # Show a diagnostic messages with virtual text
+  showDiagWithVirtualText: false,
+
+  # enable inlay hints
+  showInlayHints: false,
+
+  # In insert mode, show the current symbol signature automatically
+  showSignature: true,
+
+  # enable snippet completion support
+  snippetSupport: false,
+
+  # enable SirVer/ultisnips completion support
+  ultisnipsSupport: false,
+
+  # add to autocomplition list current buffer words
+  useBufferCompletion: false,
+
+  # Use a floating menu to show the code action menu instead of asking for
+  # input
+  usePopupInCodeAction: false,
+
+  # ShowReferences in a quickfix list instead of a location list`
+  useQuickfixForLocations: false,
+
+  # enable hrsh7th/vim-vsnip completion support
+  vsnipSupport: false,
+
+  # Limit the time autocompletion searches for words in current buffer (in
+  # milliseconds)
+  bufferCompletionTimeout: 100,
+
+  # Enable support for custom completion kinds
+  customCompletionKinds: false,
+
+  # A dictionary with all completion kinds that you want to customize
+  completionKinds: {},
+
+  # Filter duplicate completion items
+  filterCompletionDuplicates: false,
+}
+
+# set the LSP plugin options from the user provided option values
+export def OptionsSet(opts: dict<any>)
+  lspOptions->extend(opts)
+  if !has('patch-9.0.0178')
+    lspOptions.showInlayHints = false
+  endif
+  if !has('patch-9.0.1157')
+    lspOptions.showDiagWithVirtualText = false
+  endif
+
+  # For faster comparison, convert the 'completionMatcher' option value from a
+  # string to a number.
+  if lspOptions.completionMatcher == 'icase'
+    lspOptions.completionMatcherValue = COMPLETIONMATCHER_ICASE
+  elseif lspOptions.completionMatcher == 'fuzzy'
+    lspOptions.completionMatcherValue = COMPLETIONMATCHER_FUZZY
+  else
+    lspOptions.completionMatcherValue = COMPLETIONMATCHER_CASE
+  endif
+
+  # Apply the changed options
+  if exists('#LspCmds#User#LspOptionsChanged')
+    :doautocmd <nomodeline> LspCmds User LspOptionsChanged
+  endif
+enddef
+
+# return a copy of the LSP plugin options
+export def OptionsGet(): dict<any>
+  return lspOptions->deepcopy()
+enddef
+
+# vim: tabstop=8 shiftwidth=2 softtabstop=2
diff --git a/vim/pack/downloads/opt/lsp/autoload/lsp/outline.vim b/vim/pack/downloads/opt/lsp/autoload/lsp/outline.vim
new file mode 100644
index 0000000..b414884
--- /dev/null
+++ b/vim/pack/downloads/opt/lsp/autoload/lsp/outline.vim
@@ -0,0 +1,304 @@
+vim9script
+
+import './util.vim'
+import './options.vim' as opt
+
+# jump to a symbol selected in the outline window
+def OutlineJumpToSymbol()
+  var lnum: number = line('.') - 1
+  if w:lspSymbols.lnumTable[lnum]->empty()
+    return
+  endif
+
+  var slnum: number = w:lspSymbols.lnumTable[lnum].lnum
+  var scol: number = w:lspSymbols.lnumTable[lnum].col
+  var fname: string = w:lspSymbols.filename
+
+  # Highlight the selected symbol
+  prop_remove({type: 'LspOutlineHighlight'})
+  var col: number = getline('.')->match('\S') + 1
+  prop_add(line('.'), col, {type: 'LspOutlineHighlight',
+			length: w:lspSymbols.lnumTable[lnum].name->len()})
+
+  # disable the outline window refresh
+  skipRefresh = true
+
+  # If the file is already opened in a window, jump to it. Otherwise open it
+  # in another window
+  var wid: number = fname->bufwinid()
+  if wid == -1
+    # Find a window showing a normal buffer and use it
+    for w in getwininfo()
+      if w.winid->getwinvar('&buftype')->empty()
+	wid = w.winid
+	wid->win_gotoid()
+	break
+      endif
+    endfor
+    if wid == -1
+      var symWinid: number = win_getid()
+      :rightbelow vnew
+      # retain the fixed symbol window width
+      win_execute(symWinid, 'vertical resize 20')
+    endif
+
+    exe $'edit {fname}'
+  else
+    wid->win_gotoid()
+  endif
+  [slnum, scol]->cursor()
+  skipRefresh = false
+enddef
+
+# Skip refreshing the outline window. Used to prevent recursive updates to the
+# outline window
+var skipRefresh: bool = false
+
+export def SkipOutlineRefresh(): bool
+  return skipRefresh
+enddef
+
+def AddSymbolText(bnr: number,
+			symbolTypeTable: dict<list<dict<any>>>,
+			pfx: string,
+			text: list<string>,
+			lnumMap: list<dict<any>>,
+			children: bool)
+  var prefix: string = pfx .. '  '
+  for [symType, symbols] in symbolTypeTable->items()
+    if !children
+      # Add an empty line for the top level symbol types. For types in the
+      # children symbols, don't add the empty line.
+      text->extend([''])
+      lnumMap->extend([{}])
+    endif
+    if children
+      text->extend([prefix .. symType])
+      prefix ..= '  '
+    else
+      text->extend([symType])
+    endif
+    lnumMap->extend([{}])
+    for s in symbols
+      text->add(prefix .. s.name)
+      # remember the line number for the symbol
+      var s_start = s.range.start
+      var start_col: number = util.GetLineByteFromPos(bnr, s_start) + 1
+      lnumMap->add({name: s.name, lnum: s_start.line + 1,
+			col: start_col})
+      s.outlineLine = lnumMap->len()
+      if s->has_key('children') && !s.children->empty()
+	AddSymbolText(bnr, s.children, prefix, text, lnumMap, true)
+      endif
+    endfor
+  endfor
+enddef
+
+# update the symbols displayed in the outline window
+export def UpdateOutlineWindow(fname: string,
+				symbolTypeTable: dict<list<dict<any>>>,
+				symbolLineTable: list<dict<any>>)
+  var wid: number = bufwinid('LSP-Outline')
+  if wid == -1
+    return
+  endif
+
+  # stop refreshing the outline window recursively
+  skipRefresh = true
+
+  var prevWinID: number = win_getid()
+  wid->win_gotoid()
+
+  # if the file displayed in the outline window is same as the new file, then
+  # save and restore the cursor position
+  var symbols = wid->getwinvar('lspSymbols', {})
+  var saveCursor: list<number> = []
+  if !symbols->empty() && symbols.filename == fname
+    saveCursor = getcurpos()
+  endif
+
+  :setlocal modifiable
+  :silent! :%d _
+  setline(1, ['# LSP Outline View',
+		$'# {fname->fnamemodify(":t")} ({fname->fnamemodify(":h")})'])
+
+  # First two lines in the buffer display comment information
+  var lnumMap: list<dict<any>> = [{}, {}]
+  var text: list<string> = []
+  AddSymbolText(fname->bufnr(), symbolTypeTable, '', text, lnumMap, false)
+  text->append('$')
+  w:lspSymbols = {filename: fname, lnumTable: lnumMap,
+				symbolsByLine: symbolLineTable}
+  :setlocal nomodifiable
+
+  if !saveCursor->empty()
+    saveCursor->setpos('.')
+  endif
+
+  prevWinID->win_gotoid()
+
+  # Highlight the current symbol
+  OutlineHighlightCurrentSymbol()
+
+  # re-enable refreshing the outline window
+  skipRefresh = false
+enddef
+
+def OutlineHighlightCurrentSymbol()
+  var fname: string = expand('%')->fnamemodify(':p')
+  if fname->empty() || &filetype->empty()
+    return
+  endif
+
+  var wid: number = bufwinid('LSP-Outline')
+  if wid == -1
+    return
+  endif
+
+  # Check whether the symbols for this file are displayed in the outline
+  # window
+  var lspSymbols = wid->getwinvar('lspSymbols', {})
+  if lspSymbols->empty() || lspSymbols.filename != fname
+    return
+  endif
+
+  var symbolTable: list<dict<any>> = lspSymbols.symbolsByLine
+
+  # line number to locate the symbol
+  var lnum: number = line('.')
+
+  # Find the symbol for the current line number (binary search)
+  var left: number = 0
+  var right: number = symbolTable->len() - 1
+  var mid: number
+  while left <= right
+    mid = (left + right) / 2
+    var r = symbolTable[mid].range
+    if lnum >= (r.start.line + 1) && lnum <= (r.end.line + 1)
+      break
+    endif
+    if lnum > (r.start.line + 1)
+      left = mid + 1
+    else
+      right = mid - 1
+    endif
+  endwhile
+
+  # clear the highlighting in the outline window
+  var bnr: number = wid->winbufnr()
+  prop_remove({bufnr: bnr, type: 'LspOutlineHighlight'})
+
+  if left > right
+    # symbol not found
+    return
+  endif
+
+  # Highlight the selected symbol
+  var col: number =
+    bnr->getbufline(symbolTable[mid].outlineLine)->get(0, '')->match('\S') + 1
+  prop_add(symbolTable[mid].outlineLine, col,
+			{bufnr: bnr, type: 'LspOutlineHighlight',
+			length: symbolTable[mid].name->len()})
+
+  # if the line is not visible, then scroll the outline window to make the
+  # line visible
+  var wininfo = wid->getwininfo()
+  if symbolTable[mid].outlineLine < wininfo[0].topline
+			|| symbolTable[mid].outlineLine > wininfo[0].botline
+    var cmd: string = $'call cursor({symbolTable[mid].outlineLine}, 1) | normal z.'
+    win_execute(wid, cmd)
+  endif
+enddef
+
+# when the outline window is closed, do the cleanup
+def OutlineCleanup()
+  # Remove the outline autocommands
+  :silent! autocmd_delete([{group: 'LSPOutline'}])
+
+  :silent! syntax clear LSPTitle
+enddef
+
+# open the symbol outline window
+export def OpenOutlineWindow(cmdmods: string, winsize: number)
+  var wid: number = bufwinid('LSP-Outline')
+  if wid != -1
+    return
+  endif
+
+  var prevWinID: number = win_getid()
+
+  var mods = cmdmods
+  if mods->empty()
+    if opt.lspOptions.outlineOnRight
+      mods = ':vert :botright'
+    else
+      mods = ':vert :topleft'
+    endif
+  endif
+
+  var size = winsize
+  if size == 0
+    size = opt.lspOptions.outlineWinSize
+  endif
+
+  execute $'{mods} :{size}new LSP-Outline'
+  :setlocal modifiable
+  :setlocal noreadonly
+  :silent! :%d _
+  :setlocal buftype=nofile
+  :setlocal bufhidden=delete
+  :setlocal noswapfile nobuflisted
+  :setlocal nonumber norelativenumber fdc=0 nowrap winfixheight winfixwidth
+  :setlocal shiftwidth=2
+  :setlocal foldenable
+  :setlocal foldcolumn=4
+  :setlocal foldlevel=4
+  :setlocal foldmethod=indent
+  setline(1, ['# File Outline'])
+  :nnoremap <silent> <buffer> q :quit<CR>
+  :nnoremap <silent> <buffer> <CR> :call <SID>OutlineJumpToSymbol()<CR>
+  :setlocal nomodifiable
+
+  # highlight all the symbol types
+  :syntax keyword LSPTitle File Module Namespace Package Class Method Property
+  :syntax keyword LSPTitle Field Constructor Enum Interface Function Variable
+  :syntax keyword LSPTitle Constant String Number Boolean Array Object Key Null
+  :syntax keyword LSPTitle EnumMember Struct Event Operator TypeParameter
+
+  if str2nr(&t_Co) > 2
+    :highlight clear LSPTitle
+    :highlight default link LSPTitle Title
+  endif
+
+  prop_type_add('LspOutlineHighlight', {bufnr: bufnr(), highlight: 'Search', override: true})
+
+  try
+    autocmd_delete([{group: 'LSPOutline', event: '*'}])
+  catch /E367:/
+  endtry
+  var acmds: list<dict<any>>
+
+  # Refresh or add the symbols in a buffer to the outline window
+  acmds->add({event: 'BufEnter',
+	      group: 'LSPOutline',
+	      pattern: '*',
+	      cmd: 'call g:LspRequestDocSymbols()'})
+
+  # when the outline window is closed, do the cleanup
+  acmds->add({event: 'BufUnload',
+	      group: 'LSPOutline',
+	      pattern: 'LSP-Outline',
+	      cmd: 'OutlineCleanup()'})
+
+  # Highlight the current symbol when the cursor is not moved for sometime
+  acmds->add({event: 'CursorHold',
+	      group: 'LSPOutline',
+	      pattern: '*',
+	      cmd: 'OutlineHighlightCurrentSymbol()'})
+
+  autocmd_add(acmds)
+
+  prevWinID->win_gotoid()
+enddef
+
+# vim: tabstop=8 shiftwidth=2 softtabstop=2
diff --git a/vim/pack/downloads/opt/lsp/autoload/lsp/selection.vim b/vim/pack/downloads/opt/lsp/autoload/lsp/selection.vim
new file mode 100644
index 0000000..1ef289b
--- /dev/null
+++ b/vim/pack/downloads/opt/lsp/autoload/lsp/selection.vim
@@ -0,0 +1,107 @@
+vim9script
+
+# Functions related to handling LSP range selection.
+
+import './util.vim'
+
+# Visually (character-wise) select the text in a range
+def SelectText(bnr: number, range: dict<dict<number>>)
+  var rstart = range.start
+  var rend = range.end
+  var start_col: number = util.GetLineByteFromPos(bnr, rstart) + 1
+  var end_col: number = util.GetLineByteFromPos(bnr, rend)
+
+  :normal! v"_y
+  setcharpos("'<", [0, rstart.line + 1, start_col, 0])
+  setcharpos("'>", [0, rend.line + 1, end_col, 0])
+  :normal! gv
+enddef
+
+# Process the range selection reply from LSP server and start a new selection
+export def SelectionStart(lspserver: dict<any>, sel: list<dict<any>>)
+  if sel->empty()
+    return
+  endif
+
+  var bnr: number = bufnr()
+
+  # save the reply for expanding or shrinking the selected text.
+  lspserver.selection = {bnr: bnr, selRange: sel[0], index: 0}
+
+  SelectText(bnr, sel[0].range)
+enddef
+
+# Locate the range in the LSP reply at a specified level
+def GetSelRangeAtLevel(selRange: dict<any>, level: number): dict<any>
+  var r: dict<any> = selRange
+  var idx: number = 0
+
+  while idx != level
+    if !r->has_key('parent')
+      break
+    endif
+    r = r.parent
+    idx += 1
+  endwhile
+
+  return r
+enddef
+
+# Returns true if the current visual selection matches a range in the
+# selection reply from LSP.
+def SelectionFromLSP(range: dict<any>, startpos: list<number>, endpos: list<number>): bool
+  var rstart = range.start
+  var rend = range.end
+  return startpos[1] == rstart.line + 1
+			&& endpos[1] == rend.line + 1
+			&& startpos[2] == rstart.character + 1
+			&& endpos[2] == rend.character
+enddef
+
+# Expand or Shrink the current selection or start a new one.
+export def SelectionModify(lspserver: dict<any>, expand: bool)
+  var fname: string = @%
+  var bnr: number = bufnr()
+
+  if mode() == 'v' && !lspserver.selection->empty()
+					&& lspserver.selection.bnr == bnr
+					&& !lspserver.selection->empty()
+    # Already in characterwise visual mode and the previous LSP selection
+    # reply for this buffer is available. Modify the current selection.
+
+    var selRange: dict<any> = lspserver.selection.selRange
+    var startpos: list<number> = getcharpos('v')
+    var endpos: list<number> = getcharpos('.')
+    var idx: number = lspserver.selection.index
+
+    # Locate the range in the LSP reply for the current selection
+    selRange = GetSelRangeAtLevel(selRange, lspserver.selection.index)
+
+    # If the current selection is present in the LSP reply, then modify the
+    # selection
+    if SelectionFromLSP(selRange.range, startpos, endpos)
+      if expand
+	# expand the selection
+        if selRange->has_key('parent')
+          selRange = selRange.parent
+          lspserver.selection.index = idx + 1
+        endif
+      else
+	# shrink the selection
+	if idx > 0
+	  idx -= 1
+          selRange = GetSelRangeAtLevel(lspserver.selection.selRange, idx)
+	  lspserver.selection.index = idx
+	endif
+      endif
+
+      SelectText(bnr, selRange.range)
+      return
+    endif
+  endif
+
+  # Start a new selection
+  lspserver.selectionRange(fname)
+enddef
+
+# vim: tabstop=8 shiftwidth=2 softtabstop=2
diff --git a/vim/pack/downloads/opt/lsp/autoload/lsp/semantichighlight.vim b/vim/pack/downloads/opt/lsp/autoload/lsp/semantichighlight.vim
new file mode 100644
index 0000000..243aea9
--- /dev/null
+++ b/vim/pack/downloads/opt/lsp/autoload/lsp/semantichighlight.vim
@@ -0,0 +1,264 @@
+vim9script
+
+# LSP semantic highlighting functions
+
+import './offset.vim'
+import './options.vim' as opt
+import './buffer.vim' as buf
+
+# Map token type names to higlight group/text property type names
+var TokenTypeMap: dict<string> = {
+  'namespace': 'LspSemanticNamespace',
+  'type': 'LspSemanticType',
+  'class': 'LspSemanticClass',
+  'enum': 'LspSemanticEnum',
+  'interface': 'LspSemanticInterface',
+  'struct': 'LspSemanticStruct',
+  'typeParameter': 'LspSemanticTypeParameter',
+  'parameter': 'LspSemanticParameter',
+  'variable': 'LspSemanticVariable',
+  'property': 'LspSemanticProperty',
+  'enumMember': 'LspSemanticEnumMember',
+  'event': 'LspSemanticEvent',
+  'function': 'LspSemanticFunction',
+  'method': 'LspSemanticMethod',
+  'macro': 'LspSemanticMacro',
+  'keyword': 'LspSemanticKeyword',
+  'modifier': 'LspSemanticModifier',
+  'comment': 'LspSemanticComment',
+  'string': 'LspSemanticString',
+  'number': 'LspSemanticNumber',
+  'regexp': 'LspSemanticRegexp',
+  'operator': 'LspSemanticOperator',
+  'decorator': 'LspSemanticDecorator'
+}
+
+export def InitOnce()
+  # Define the default semantic token type highlight groups
+  hlset([
+    {name: 'LspSemanticNamespace', default: true, linksto: 'Type'},
+    {name: 'LspSemanticType', default: true, linksto: 'Type'},
+    {name: 'LspSemanticClass', default: true, linksto: 'Type'},
+    {name: 'LspSemanticEnum', default: true, linksto: 'Type'},
+    {name: 'LspSemanticInterface', default: true, linksto: 'TypeDef'},
+    {name: 'LspSemanticStruct', default: true, linksto: 'Type'},
+    {name: 'LspSemanticTypeParameter', default: true, linksto: 'Type'},
+    {name: 'LspSemanticParameter', default: true, linksto: 'Identifier'},
+    {name: 'LspSemanticVariable', default: true, linksto: 'Identifier'},
+    {name: 'LspSemanticProperty', default: true, linksto: 'Identifier'},
+    {name: 'LspSemanticEnumMember', default: true, linksto: 'Constant'},
+    {name: 'LspSemanticEvent', default: true, linksto: 'Identifier'},
+    {name: 'LspSemanticFunction', default: true, linksto: 'Function'},
+    {name: 'LspSemanticMethod', default: true, linksto: 'Function'},
+    {name: 'LspSemanticMacro', default: true, linksto: 'Macro'},
+    {name: 'LspSemanticKeyword', default: true, linksto: 'Keyword'},
+    {name: 'LspSemanticModifier', default: true, linksto: 'Type'},
+    {name: 'LspSemanticComment', default: true, linksto: 'Comment'},
+    {name: 'LspSemanticString', default: true, linksto: 'String'},
+    {name: 'LspSemanticNumber', default: true, linksto: 'Number'},
+    {name: 'LspSemanticRegexp', default: true, linksto: 'String'},
+    {name: 'LspSemanticOperator', default: true, linksto: 'Operator'},
+    {name: 'LspSemanticDecorator', default: true, linksto: 'Macro'}
+  ])
+
+  for hlName in TokenTypeMap->values()
+    prop_type_add(hlName, {highlight: hlName, combine: true})
+  endfor
+enddef
+
+def ParseSemanticTokenMods(lspserverTokenMods: list<string>, tokenMods: number): string
+  var n = tokenMods
+  var tokenMod: number
+  var str = ''
+
+  while n > 0
+    tokenMod = float2nr(log10(and(n, invert(n - 1))) / log10(2))
+    str = $'{str}{lspserverTokenMods[tokenMod]},'
+    n = and(n, n - 1)
+  endwhile
+
+  return str
+enddef
+
+# Apply the edit operations in a semantic tokens delta update message
+# (SemanticTokensDelta) from the language server.
+#
+# The previous list of tokens are stored in the buffer-local
+# LspSemanticTokensData variable.  After applying the edits in
+# semTokens.edits, the new set of tokens are returned in semTokens.data.
+def ApplySemanticTokenEdits(bnr: number, semTokens: dict<any>)
+  if semTokens.edits->empty()
+    return
+  endif
+
+  # Need to sort the edits and apply the last edit first.
+  semTokens.edits->sort((a: dict<any>, b: dict<any>) => a.start - b.start)
+
+  # TODO: Remove this code
+  # var d = bnr->getbufvar('LspSemanticTokensData', [])
+  # for e in semTokens.edits
+  #   var insertData = e->get('data', [])
+  #   d = (e.start > 0 ? d[: e.start - 1] : []) + insertData +
+  #     					d[e.start + e.deleteCount :]
+  # endfor
+  # semTokens.data = d
+
+  var oldTokens = bnr->getbufvar('LspSemanticTokensData', [])
+  var newTokens = []
+  var idx = 0
+  for e in semTokens.edits
+    if e.start > 0
+      newTokens->extend(oldTokens[idx : e.start - 1])
+    endif
+    newTokens->extend(e->get('data', []))
+    idx = e.start + e.deleteCount
+  endfor
+  newTokens->extend(oldTokens[idx : ])
+  semTokens.data = newTokens
+enddef
+
+# Process a list of semantic tokens and return the corresponding text
+# properties for highlighting.
+def ProcessSemanticTokens(lspserver: dict<any>, bnr: number, tokens: list<number>): dict<list<list<number>>>
+  var props: dict<list<list<number>>> = {}
+  var tokenLine: number = 0
+  var startChar: number = 0
+  var length: number = 0
+  var tokenType: number = 0
+  var tokenMods: number = 0
+  var prevTokenLine = 0
+  var lnum = 1
+  var charIdx = 0
+
+  var lspserverTokenTypes: list<string> =
+				lspserver.semanticTokensLegend.tokenTypes
+  var lspserverTokenMods: list<string> =
+				lspserver.semanticTokensLegend.tokenModifiers
+
+  # Each semantic token uses 5 items in the tokens List
+  var i = 0
+  while i < tokens->len()
+    tokenLine = tokens[i]
+    # tokenLine is relative to the previous token line number
+    lnum += tokenLine
+    if prevTokenLine != lnum
+      # this token is on a different line from the previous token
+      charIdx = 0
+      prevTokenLine = lnum
+    endif
+    startChar = tokens[i + 1]
+    charIdx += startChar
+    length = tokens[i + 2]
+    tokenType = tokens[i + 3]
+    tokenMods = tokens[i + 4]
+
+    var typeStr = lspserverTokenTypes[tokenType]
+    var modStr = ParseSemanticTokenMods(lspserverTokenMods, tokenMods)
+
+    # Decode the semantic token line number, column number and length to
+    # UTF-32 encoding.
+    var r = {
+      start: {
+	line: lnum - 1,
+	character: charIdx
+      },
+      end: {
+	line: lnum - 1,
+	character: charIdx + length
+      }
+    }
+    offset.DecodeRange(lspserver, bnr, r)
+
+    if !props->has_key(typeStr)
+      props[typeStr] = []
+    endif
+    props[typeStr]->add([
+	lnum, r.start.character + 1,
+	lnum, r.end.character + 1
+      ])
+
+    i += 5
+  endwhile
+
+  return props
+enddef
+
+# Parse the semantic highlight reply from the language server and update the
+# text properties
+export def UpdateTokens(lspserver: dict<any>, bnr: number, semTokens: dict<any>)
+
+  if semTokens->has_key('edits')
+    # Delta semantic update.  Need to sort the edits and apply the last edit
+    # first.
+    ApplySemanticTokenEdits(bnr, semTokens)
+  endif
+
+  # Cache the semantic tokens in a buffer-local variable, it will be used
+  # later for a delta update.
+  setbufvar(bnr, 'LspSemanticResultId', semTokens->get('resultId', ''))
+  if !semTokens->has_key('data')
+    return
+  endif
+  setbufvar(bnr, 'LspSemanticTokensData', semTokens.data)
+
+  var props: dict<list<list<number>>>
+  props = ProcessSemanticTokens(lspserver, bnr, semTokens.data)
+
+  # First clear all the previous text properties
+  if has('patch-9.0.0233')
+    prop_remove({types: TokenTypeMap->values(), bufnr: bnr, all: true})
+  else
+    for propName in TokenTypeMap->values()
+      prop_remove({type: propName, bufnr: bnr, all: true})
+    endfor
+  endif
+
+  if props->empty()
+    return
+  endif
+
+  # Apply the new text properties
+  for tokenType in TokenTypeMap->keys()
+    if props->has_key(tokenType)
+      prop_add_list({bufnr: bnr, type: TokenTypeMap[tokenType]},
+	props[tokenType])
+    endif
+  endfor
+enddef
+
+# Update the semantic highlighting for buffer "bnr"
+def LspUpdateSemanticHighlight(bnr: number)
+  var lspserver: dict<any> = buf.BufLspServerGet(bnr, 'semanticTokens')
+  if lspserver->empty()
+    return
+  endif
+
+  lspserver.semanticHighlightUpdate(bnr)
+enddef
+
+# Initialize the semantic highlighting for the buffer 'bnr'
+export def BufferInit(lspserver: dict<any>, bnr: number)
+  if !opt.lspOptions.semanticHighlight || !lspserver.isSemanticTokensProvider
+    # no support for semantic highlighting
+    return
+  endif
+
+  # Highlight all the semantic tokens
+  LspUpdateSemanticHighlight(bnr)
+
+  # buffer-local autocmds for semantic highlighting
+  var acmds: list<dict<any>> = []
+
+  acmds->add({bufnr: bnr,
+	      event: 'TextChanged',
+	      group: 'LSPBufferAutocmds',
+	      cmd: $'LspUpdateSemanticHighlight({bnr})'})
+  acmds->add({bufnr: bnr,
+	      event: 'BufUnload',
+	      group: 'LSPBufferAutocmds',
+	      cmd: $"b:LspSemanticTokensData = [] | b:LspSemanticResultId = ''"})
+
+  autocmd_add(acmds)
+enddef
+
+# vim: tabstop=8 shiftwidth=2 softtabstop=2
diff --git a/vim/pack/downloads/opt/lsp/autoload/lsp/signature.vim b/vim/pack/downloads/opt/lsp/autoload/lsp/signature.vim
new file mode 100644
index 0000000..ca2bed4
--- /dev/null
+++ b/vim/pack/downloads/opt/lsp/autoload/lsp/signature.vim
@@ -0,0 +1,145 @@
+vim9script
+
+# Functions related to handling LSP symbol signature help.
+
+import './options.vim' as opt
+import './util.vim'
+import './buffer.vim' as buf
+
+# close the signature popup window
+def CloseSignaturePopup(lspserver: dict<any>)
+  if lspserver.signaturePopup != -1
+    lspserver.signaturePopup->popup_close()
+  endif
+  lspserver.signaturePopup = -1
+enddef
+
+def CloseCurBufSignaturePopup()
+  var lspserver: dict<any> = buf.CurbufGetServer('signatureHelp')
+  if lspserver->empty()
+    return
+  endif
+
+  CloseSignaturePopup(lspserver)
+enddef
+
+# Show the signature using "textDocument/signatureHelp" LSP method
+# Invoked from an insert-mode mapping, so return an empty string.
+def g:LspShowSignature(): string
+  var lspserver: dict<any> = buf.CurbufGetServerChecked('signatureHelp')
+  if lspserver->empty()
+    return ''
+  endif
+
+  # first send all the changes in the current buffer to the LSP server
+  listener_flush()
+  lspserver.showSignature()
+  return ''
+enddef
+
+export def InitOnce()
+  hlset([{name: 'LspSigActiveParameter', default: true, linksto: 'LineNr'}])
+enddef
+
+# Initialize the signature triggers for the current buffer
+export def BufferInit(lspserver: dict<any>)
+  if !lspserver.isSignatureHelpProvider
+	|| !lspserver.caps.signatureHelpProvider->has_key('triggerCharacters')
+    # no support for signature help
+    return
+  endif
+
+  if !opt.lspOptions.showSignature
+      || !lspserver.featureEnabled('signatureHelp')
+    # Show signature support is disabled
+    return
+  endif
+
+  # map characters that trigger signature help
+  for ch in lspserver.caps.signatureHelpProvider.triggerCharacters
+    exe $"inoremap <buffer> <silent> {ch} {ch}<C-R>=g:LspShowSignature()<CR>"
+  endfor
+
+  # close the signature popup when leaving insert mode
+  autocmd_add([{bufnr: bufnr(),
+		event: 'InsertLeave',
+		cmd: 'CloseCurBufSignaturePopup()'}])
+enddef
+
+# process the 'textDocument/signatureHelp' reply from the LSP server and
+# display the symbol signature help.
+# Result: SignatureHelp | null
+export def SignatureHelp(lspserver: dict<any>, sighelp: any): void
+  if sighelp->empty()
+    CloseSignaturePopup(lspserver)
+    return
+  endif
+
+  if sighelp.signatures->len() <= 0
+    CloseSignaturePopup(lspserver)
+    return
+  endif
+
+  var sigidx: number = 0
+  if sighelp->has_key('activeSignature')
+    sigidx = sighelp.activeSignature
+  endif
+
+  var sig: dict<any> = sighelp.signatures[sigidx]
+  var text: string = sig.label
+  var hllen: number = 0
+  var startcol: number = 0
+  if sig->has_key('parameters') && sighelp->has_key('activeParameter')
+    var params: list<dict<any>> = sig.parameters
+    var params_len: number = params->len()
+    var activeParam: number = sighelp.activeParameter
+    if params_len > 0 && activeParam < params_len
+      var paramInfo: dict<any> = params[activeParam]
+      var label: any = paramInfo.label
+      if label->type() == v:t_string
+	# label string
+	var label_str: string = label
+	hllen = label_str->len()
+	startcol = text->stridx(label_str)
+      else
+	# [inclusive start offset, exclusive end offset]
+	var label_offset: list<number> = params[activeParam].label
+	var start_offset: number = label_offset[0]
+	var end_offset: number = label_offset[1]
+
+	if has('patch-9.0.1629')
+	  # Convert UTF-16 offsets
+	  startcol = text->byteidx(start_offset, true)
+	  var endcol: number = text->byteidx(end_offset, true)
+	  hllen = endcol - startcol
+	else
+	  startcol = start_offset
+	  hllen = end_offset - start_offset
+	endif
+      endif
+    endif
+  endif
+
+  if opt.lspOptions.echoSignature
+    :echon "\r\r"
+    :echon ''
+    :echon text->strpart(0, startcol)
+    :echoh LspSigActiveParameter
+    :echon text->strpart(startcol, hllen)
+    :echoh None
+    :echon text->strpart(startcol + hllen)
+  else
+    # Close the previous signature popup and open a new one
+    lspserver.signaturePopup->popup_close()
+
+    var popupID = text->popup_atcursor({padding: [0, 1, 0, 1], moved: [col('.') - 1, 9999999]})
+    var bnr: number = popupID->winbufnr()
+    prop_type_add('signature', {bufnr: bnr, highlight: 'LspSigActiveParameter'})
+    if hllen > 0
+      prop_add(1, startcol + 1, {bufnr: bnr, length: hllen, type: 'signature'})
+    endif
+    lspserver.signaturePopup = popupID
+  endif
+enddef
+
+# vim: tabstop=8 shiftwidth=2 softtabstop=2
diff --git a/vim/pack/downloads/opt/lsp/autoload/lsp/snippet.vim b/vim/pack/downloads/opt/lsp/autoload/lsp/snippet.vim
new file mode 100644
index 0000000..c03b49d
--- /dev/null
+++ b/vim/pack/downloads/opt/lsp/autoload/lsp/snippet.vim
@@ -0,0 +1,82 @@
+vim9script
+
+# Snippet support
+
+# Integration with the UltiSnips plugin
+export def CompletionUltiSnips(prefix: string, items: list<dict<any>>)
+  call UltiSnips#SnippetsInCurrentScope(1)
+  for key in matchfuzzy(g:current_ulti_dict_info->keys(), prefix)
+    var item = g:current_ulti_dict_info[key]
+    var parts = split(item.location, ':')
+    var txt = parts[0]->readfile()[parts[1]->str2nr() : parts[1]->str2nr() + 20]
+    var restxt = item.description .. "\n\n"
+    for line in txt
+      if line->empty() || line[0 : 6] == "snippet"
+	break
+      else
+	restxt = restxt .. line .. "\n"
+      endif
+    endfor
+    items->add({
+      label: key,
+      data: {
+	entryNames: [key],
+      },
+      kind: 15,
+      documentation: restxt,
+    })
+  endfor
+enddef
+
+# Integration with the vim-vsnip plugin
+export def CompletionVsnip(items: list<dict<any>>)
+  def Pattern(abbr: string): string
+    var chars = escape(abbr, '\/?')->split('\zs')
+    var chars_pattern = '\%(\V' .. chars->join('\m\|\V') .. '\m\)'
+    var separator = chars[0] =~ '\a' ? '\<' : ''
+    return $'{separator}\V{chars[0]}\m{chars_pattern}*$'
+  enddef
+
+  if charcol('.') == 1
+    return
+  endif
+  var starttext = getline('.')->slice(0, charcol('.') - 1)
+  for item in vsnip#get_complete_items(bufnr())
+    var match = starttext->matchstrpos(Pattern(item.abbr))
+    if match[0] != ''
+      var user_data = item.user_data->json_decode()
+      var documentation = []
+      for line in vsnip#to_string(user_data.vsnip.snippet)->split("\n")
+	documentation->add(line)
+      endfor
+      items->add({
+	label: item.abbr,
+	filterText: item.word,
+	insertTextFormat: 2,
+	textEdit: {
+	  newText: user_data.vsnip.snippet->join("\n"),
+	  range: {
+	    start: {
+	      line: line('.'),
+	      character: match[1],
+	    },
+	    ['end']: {
+	      line: line('.'),
+	      character: match[2],
+	    },
+	  },
+	},
+	data: {
+	  entryNames: [item.word],
+	},
+	kind: 15,
+	documentation: {
+	  kind: 'markdown',
+	  value: documentation->join("\n"),
+	},
+      })
+    endif
+  endfor
+enddef
+
+# vim: tabstop=8 shiftwidth=2 softtabstop=2
diff --git a/vim/pack/downloads/opt/lsp/autoload/lsp/symbol.vim b/vim/pack/downloads/opt/lsp/autoload/lsp/symbol.vim
new file mode 100644
index 0000000..bcd547a
--- /dev/null
+++ b/vim/pack/downloads/opt/lsp/autoload/lsp/symbol.vim
@@ -0,0 +1,1014 @@
+vim9script
+
+# Functions for dealing with symbols.
+#   - LSP symbol menu and for searching symbols across the workspace.
+#   - show locations
+#   - jump to a symbol definition, declaration, type definition or
+#     implementation
+
+import './options.vim' as opt
+import './util.vim'
+import './outline.vim'
+
+# Initialize the highlight group and the text property type used for
+# document symbol search
+export def InitOnce()
+  # Use a high priority value to override other highlights in the line
+  hlset([
+    {name: 'LspSymbolName', default: true, linksto: 'Search'},
+    {name: 'LspSymbolRange', default: true, linksto: 'Visual'}
+  ])
+  prop_type_add('LspSymbolNameProp', {highlight: 'LspSymbolName',
+				       combine: false,
+				       override: true,
+				       priority: 201})
+  prop_type_add('LspSymbolRangeProp', {highlight: 'LspSymbolRange',
+				       combine: false,
+				       override: true,
+				       priority: 200})
+enddef
+
+# Handle keys pressed when the workspace symbol popup menu is displayed
+def FilterSymbols(lspserver: dict<any>, popupID: number, key: string): bool
+  var key_handled: bool = false
+  var update_popup: bool = false
+  var query: string = lspserver.workspaceSymbolQuery
+
+  if key == "\<BS>" || key == "\<C-H>"
+    # Erase one character from the filter text
+    if query->len() >= 1
+      query = query[: -2]
+      update_popup = true
+    endif
+    key_handled = true
+  elseif key == "\<C-U>"
+    # clear the filter text
+    query = ''
+    update_popup = true
+    key_handled = true
+  elseif key == "\<C-F>"
+        || key == "\<C-B>"
+        || key == "\<PageUp>"
+        || key == "\<PageDown>"
+        || key == "\<C-Home>"
+        || key == "\<C-End>"
+        || key == "\<C-N>"
+        || key == "\<C-P>"
+    # scroll the popup window
+    var cmd: string = 'normal! ' .. (key == "\<C-N>" ? 'j' : key == "\<C-P>" ? 'k' : key)
+    win_execute(popupID, cmd)
+    key_handled = true
+  elseif key == "\<Up>" || key == "\<Down>"
+    # Use native Vim handling for these keys
+    key_handled = false
+  elseif key =~ '^\f$' || key == "\<Space>"
+    # Filter the names based on the typed key and keys typed before
+    query ..= key
+    update_popup = true
+    key_handled = true
+  endif
+
+  if update_popup
+    # Update the popup with the new list of symbol names
+    popupID->popup_settext('')
+    if query != ''
+      lspserver.workspaceQuery(query, false)
+    else
+      []->setwinvar(popupID, 'LspSymbolTable')
+    endif
+    :echo $'Symbol: {query}'
+  endif
+
+  # Update the workspace symbol query string
+  lspserver.workspaceSymbolQuery = query
+
+  if key_handled
+    return true
+  endif
+
+  return popupID->popup_filter_menu(key)
+enddef
+
+# Jump to the location of a symbol selected in the popup menu
+def JumpToWorkspaceSymbol(cmdmods: string, popupID: number, result: number): void
+  # clear the message displayed at the command-line
+  :echo ''
+
+  if result <= 0
+    # popup is canceled
+    return
+  endif
+
+  var symTbl: list<dict<any>> = popupID->getwinvar('LspSymbolTable', [])
+  if symTbl->empty()
+    return
+  endif
+  try
+    # Save the current location in the tag stack
+    util.PushCursorToTagStack()
+
+    # if the selected file is already present in a window, then jump to it
+    var fname: string = symTbl[result - 1].file
+    var bnr = fname->bufnr()
+    if cmdmods->empty()
+      var winList: list<number> = bnr->win_findbuf()
+      if winList->empty()
+	# Not present in any window
+	if &modified || &buftype != ''
+	  # the current buffer is modified or is not a normal buffer, then
+	  # open the file in a new window
+	  exe $'split {symTbl[result - 1].file}'
+	else
+	  exe $'confirm edit {symTbl[result - 1].file}'
+	endif
+      else
+	# If the target buffer is opened in the current window, then don't
+	# change the window.
+	if bufnr() != bnr
+	  # If the target buffer is opened in a window in the current tab
+	  # page, then use it.
+	  var winID = fname->bufwinid()
+	  if winID == -1
+	    # not present in the current tab page.  Use the first window.
+	    winID = winList[0]
+	  endif
+	  winID->win_gotoid()
+	endif
+      endif
+    else
+      exe $'{cmdmods} split {symTbl[result - 1].file}'
+    endif
+    # Set the previous cursor location mark. Instead of using setpos(), m' is
+    # used so that the current location is added to the jump list.
+    :normal m'
+    setcursorcharpos(symTbl[result - 1].pos.line + 1,
+		     util.GetCharIdxWithoutCompChar(bufnr(),
+						    symTbl[result - 1].pos) + 1)
+    :normal! zv
+  catch
+    # ignore exceptions
+  endtry
+enddef
+
+# display a list of symbols from the workspace
+def ShowSymbolMenu(lspserver: dict<any>, query: string, cmdmods: string)
+  # Create the popup menu
+  var lnum = &lines - &cmdheight - 2 - 10
+  var popupAttr = {
+      title: 'Workspace Symbol Search',
+      wrap: false,
+      pos: 'topleft',
+      line: lnum,
+      col: 2,
+      minwidth: 60,
+      minheight: 10,
+      maxheight: 10,
+      maxwidth: 60,
+      mapping: false,
+      fixed: 1,
+      close: 'button',
+      filter: function(FilterSymbols, [lspserver]),
+      callback: function('JumpToWorkspaceSymbol', [cmdmods])
+  }
+  lspserver.workspaceSymbolPopup = popup_menu([], popupAttr)
+  lspserver.workspaceSymbolQuery = query
+  prop_type_add('lspworkspacesymbol',
+			{bufnr: lspserver.workspaceSymbolPopup->winbufnr(),
+			 highlight: 'Title'})
+  :echo $'Symbol: {query}'
+enddef
+
+# Convert a file name to <filename> (<dirname>) format.
+# Make sure the popup doesn't occupy the entire screen by reducing the width.
+def MakeMenuName(popupWidth: number, fname: string): string
+  var filename: string = fname->fnamemodify(':t')
+  var flen: number = filename->len()
+  var dirname: string = fname->fnamemodify(':h')
+
+  if fname->len() > popupWidth && flen < popupWidth
+    # keep the full file name and reduce directory name length
+    # keep some characters at the beginning and end (equally).
+    # 6 spaces are used for "..." and " ()"
+    var dirsz = (popupWidth - flen - 6) / 2
+    dirname = dirname[: dirsz] .. '...' .. dirname[-dirsz : ]
+  endif
+  var str: string = filename
+  if dirname != '.'
+    str ..= $' ({dirname}/)'
+  endif
+  return str
+enddef
+
+# process the 'workspace/symbol' reply from the LSP server
+# Result: SymbolInformation[] | null
+export def WorkspaceSymbolPopup(lspserver: dict<any>, query: string,
+				symInfo: list<dict<any>>, cmdmods: string)
+  var symbols: list<dict<any>> = []
+  var symbolType: string
+  var fileName: string
+  var symName: string
+
+  # Create a symbol popup menu if it is not present
+  if lspserver.workspaceSymbolPopup->winbufnr() == -1
+    ShowSymbolMenu(lspserver, query, cmdmods)
+  endif
+
+  for symbol in symInfo
+    if !symbol->has_key('location')
+      # ignore entries without location information
+      continue
+    endif
+
+    # interface SymbolInformation
+    fileName = util.LspUriToFile(symbol.location.uri)
+
+    symName = symbol.name
+    if symbol->has_key('containerName') && symbol.containerName != ''
+      symName = $'{symbol.containerName}::{symName}'
+    endif
+    symName ..= $' [{SymbolKindToName(symbol.kind)}]'
+    symName ..= ' ' .. MakeMenuName(
+		lspserver.workspaceSymbolPopup->popup_getpos().core_width,
+		fileName)
+
+    symbols->add({name: symName,
+			file: fileName,
+			pos: symbol.location.range.start})
+  endfor
+  symbols->setwinvar(lspserver.workspaceSymbolPopup, 'LspSymbolTable')
+  lspserver.workspaceSymbolPopup->popup_settext(
+				symbols->copy()->mapnew('v:val.name'))
+enddef
+
+# map the LSP symbol kind number to string
+export def SymbolKindToName(symkind: number): string
+  var symbolMap: list<string> = [
+    '',
+    'File',
+    'Module',
+    'Namespace',
+    'Package',
+    'Class',
+    'Method',
+    'Property',
+    'Field',
+    'Constructor',
+    'Enum',
+    'Interface',
+    'Function',
+    'Variable',
+    'Constant',
+    'String',
+    'Number',
+    'Boolean',
+    'Array',
+    'Object',
+    'Key',
+    'Null',
+    'EnumMember',
+    'Struct',
+    'Event',
+    'Operator',
+    'TypeParameter'
+  ]
+  if symkind > 26
+    return ''
+  endif
+  return symbolMap[symkind]
+enddef
+
+def UpdatePeekFilePopup(lspserver: dict<any>, locations: list<dict<any>>)
+  if lspserver.peekSymbolPopup->winbufnr() == -1
+    return
+  endif
+
+  lspserver.peekSymbolFilePopup->popup_close()
+
+  var n = line('.', lspserver.peekSymbolPopup) - 1
+  var [uri, range] = util.LspLocationParse(locations[n])
+  var fname: string = util.LspUriToFile(uri)
+
+  var bnr: number = fname->bufnr()
+  if bnr == -1
+    bnr = fname->bufadd()
+  endif
+
+  var popupAttrs = {
+    title: $"{fname->fnamemodify(':t')} ({fname->fnamemodify(':h')})",
+    wrap: false,
+    fixed: true,
+    minheight: 10,
+    maxheight: 10,
+    minwidth: winwidth(0) - 38,
+    maxwidth: winwidth(0) - 38,
+    cursorline: true,
+    border: [],
+    mapping: false,
+    line: 'cursor+1',
+    col: 1
+  }
+
+  lspserver.peekSymbolFilePopup = popup_create(bnr, popupAttrs)
+  var rstart = range.start
+  var cmds =<< trim eval END
+    :setlocal number
+    [{rstart.line + 1}, 1]->cursor()
+    :normal! z.
+  END
+  win_execute(lspserver.peekSymbolFilePopup, cmds)
+
+  lspserver.peekSymbolFilePopup->clearmatches()
+  var start_col = util.GetLineByteFromPos(bnr, rstart) + 1
+  var end_col = util.GetLineByteFromPos(bnr, range.end)
+  var pos = [[rstart.line + 1,
+	     start_col, end_col - start_col + 1]]
+  matchaddpos('Search', pos, 10, -1, {window: lspserver.peekSymbolFilePopup})
+enddef
+
+def LocPopupFilter(lspserver: dict<any>, locations: list<dict<any>>,
+                   popup_id: number, key: string): bool
+  popup_filter_menu(popup_id, key)
+  if lspserver.peekSymbolPopup->winbufnr() == -1
+    if lspserver.peekSymbolFilePopup->winbufnr() != -1
+      lspserver.peekSymbolFilePopup->popup_close()
+    endif
+    lspserver.peekSymbolPopup = -1
+    lspserver.peekSymbolFilePopup = -1
+  else
+    UpdatePeekFilePopup(lspserver, locations)
+  endif
+  return true
+enddef
+
+def LocPopupCallback(lspserver: dict<any>, locations: list<dict<any>>,
+		     popup_id: number, selIdx: number)
+  if lspserver.peekSymbolFilePopup->winbufnr() != -1
+    lspserver.peekSymbolFilePopup->popup_close()
+  endif
+  lspserver.peekSymbolPopup = -1
+  if selIdx != -1
+    util.PushCursorToTagStack()
+    util.JumpToLspLocation(locations[selIdx - 1], '')
+  endif
+enddef
+
+# Display the locations in a popup menu.  Display the corresponding file in
+# an another popup window.
+def PeekLocations(lspserver: dict<any>, locations: list<dict<any>>,
+                  title: string)
+  if lspserver.peekSymbolPopup->winbufnr() != -1
+    # If the symbol popup window is already present, close it.
+    lspserver.peekSymbolPopup->popup_close()
+  endif
+
+  var w: number = &columns
+  var fnamelen = float2nr(w * 0.4)
+
+  var curlnum = line('.')
+  var symIdx = 1
+  var curSymIdx = 1
+  var menuItems: list<string> = []
+  for loc in locations
+    var [uri, range] = util.LspLocationParse(loc)
+    var fname: string = util.LspUriToFile(uri)
+    var bnr: number = fname->bufnr()
+    if bnr == -1
+      bnr = fname->bufadd()
+    endif
+    :silent! bnr->bufload()
+
+    var lnum = range.start.line + 1
+    var text: string = bnr->getbufline(lnum)->get(0, '')
+    menuItems->add($'{lnum}: {text}')
+
+    if lnum == curlnum
+      curSymIdx = symIdx
+    endif
+    symIdx += 1
+  endfor
+
+  var popupAttrs = {
+    title: title,
+    wrap: false,
+    pos: 'topleft',
+    line: 'cursor+1',
+    col: winwidth(0) - 34,
+    minheight: 10,
+    maxheight: 10,
+    minwidth: 30,
+    maxwidth: 30,
+    mapping: false,
+    fixed: true,
+    filter: function(LocPopupFilter, [lspserver, locations]),
+    callback: function(LocPopupCallback, [lspserver, locations])
+  }
+  lspserver.peekSymbolPopup = popup_menu(menuItems, popupAttrs)
+  # Select the current symbol in the menu
+  var cmds =<< trim eval END
+    [{curSymIdx}, 1]->cursor()
+  END
+  win_execute(lspserver.peekSymbolPopup, cmds, 'silent!')
+  UpdatePeekFilePopup(lspserver, locations)
+enddef
+
+export def ShowLocations(lspserver: dict<any>, locations: list<dict<any>>,
+                         peekSymbol: bool, title: string)
+  if peekSymbol
+    PeekLocations(lspserver, locations, title)
+    return
+  endif
+
+  # create a loclist the location of the locations
+  var qflist: list<dict<any>> = []
+  for loc in locations
+    var [uri, range] = util.LspLocationParse(loc)
+    var fname: string = util.LspUriToFile(uri)
+    var bnr: number = fname->bufnr()
+    if bnr == -1
+      bnr = fname->bufadd()
+    endif
+    :silent! bnr->bufload()
+    var rstart = range.start
+    var text: string = bnr->getbufline(rstart.line + 1)->get(0, '')->trim("\t ", 1)
+    qflist->add({filename: fname,
+			lnum: rstart.line + 1,
+			col: util.GetLineByteFromPos(bnr, rstart) + 1,
+			text: text})
+  endfor
+
+  var save_winid = win_getid()
+
+  if opt.lspOptions.useQuickfixForLocations
+    setqflist([], ' ', {title: title, items: qflist})
+    var mods: string = ''
+    exe $'{mods} copen'
+  else
+    setloclist(0, [], ' ', {title: title, items: qflist})
+    var mods: string = ''
+    exe $'{mods} lopen'
+  endif
+
+  if !opt.lspOptions.keepFocusInReferences
+    save_winid->win_gotoid()
+  endif
+enddef
+
+# Key filter callback function used for the symbol popup window.
+# Vim doesn't close the popup window when the escape key is pressed.
+# This is function supports that.
+def SymbolFilterCB(lspserver: dict<any>, id: number, key: string): bool
+  if key == "\<Esc>"
+    lspserver.peekSymbolPopup->popup_close()
+    return true
+  endif
+
+  return false
+enddef
+
+# Display the file specified by LSP "LocationLink" in a popup window and
+# highlight the range in "location".
+def PeekSymbolLocation(lspserver: dict<any>, location: dict<any>)
+  var [uri, range] = util.LspLocationParse(location)
+  var fname = util.LspUriToFile(uri)
+  var bnum = fname->bufadd()
+  if bnum == 0
+    # Failed to create or find a buffer
+    return
+  endif
+  :silent! bnum->bufload()
+
+  if lspserver.peekSymbolPopup->winbufnr() != -1
+    # If the symbol popup window is already present, close it.
+    lspserver.peekSymbolPopup->popup_close()
+  endif
+  var CbFunc = function(SymbolFilterCB, [lspserver])
+  var popupAttrs = {
+    title: $"{fnamemodify(fname, ':t')} ({fnamemodify(fname, ':h')})",
+    wrap: false,
+    moved: 'any',
+    minheight: 10,
+    maxheight: 10,
+    minwidth: 10,
+    maxwidth: 60,
+    cursorline: true,
+    border: [],
+    mapping: false,
+    filter: CbFunc
+  }
+  lspserver.peekSymbolPopup = popup_atcursor(bnum, popupAttrs)
+
+  # Highlight the symbol name and center the line in the popup
+  var pwid = lspserver.peekSymbolPopup
+  var pwbuf = pwid->winbufnr()
+  var pos: list<number> = []
+  var start_col: number
+  var end_col: number
+  var rstart = range.start
+  start_col = util.GetLineByteFromPos(pwbuf, rstart) + 1
+  end_col = util.GetLineByteFromPos(pwbuf, range.end) + 1
+  pos->add(rstart.line + 1)
+  pos->extend([start_col, end_col - start_col])
+  matchaddpos('Search', [pos], 10, 101, {window: pwid})
+  var cmds =<< trim eval END
+    :setlocal number
+    [{rstart.line + 1}, 1]->cursor()
+    :normal! z.
+  END
+  win_execute(pwid, cmds, 'silent!')
+enddef
+
+# Jump to the definition, declaration or implementation of a symbol.
+# Also, used to peek at the definition, declaration or implementation of a
+# symbol.
+export def GotoSymbol(lspserver: dict<any>, location: dict<any>,
+		      peekSymbol: bool, cmdmods: string)
+  if peekSymbol
+    PeekSymbolLocation(lspserver, location)
+  else
+    # Save the current cursor location in the tag stack.
+    util.PushCursorToTagStack()
+    util.JumpToLspLocation(location, cmdmods)
+  endif
+enddef
+
+# Process the LSP server reply message for a 'textDocument/definition' request
+# and return a list of Dicts in a format accepted by the 'tagfunc' option.
+export def TagFunc(lspserver: dict<any>,
+			taglocations: list<dict<any>>,
+			pat: string): list<dict<any>>
+  var retval: list<dict<any>>
+
+  for tagloc in taglocations
+    var tagitem = {}
+    tagitem.name = pat
+
+    var [uri, range] = util.LspLocationParse(tagloc)
+    tagitem.filename = util.LspUriToFile(uri)
+    var bnr = util.LspUriToBufnr(uri)
+    var rstart = range.start
+    var startByteIdx = util.GetLineByteFromPos(bnr, rstart)
+    tagitem.cmd = $"/\\%{rstart.line + 1}l\\%{startByteIdx + 1}c"
+
+    retval->add(tagitem)
+  endfor
+
+  return retval
+enddef
+
+# process SymbolInformation[]
+def ProcessSymbolInfoTable(lspserver: dict<any>,
+			   bnr: number,
+			   symbolInfoTable: list<dict<any>>,
+			   symbolTypeTable: dict<list<dict<any>>>,
+			   symbolLineTable: list<dict<any>>)
+  var fname: string
+  var symbolType: string
+  var name: string
+  var r: dict<dict<number>>
+  var symInfo: dict<any>
+
+  for syminfo in symbolInfoTable
+    fname = util.LspUriToFile(syminfo.location.uri)
+    symbolType = SymbolKindToName(syminfo.kind)
+    name = syminfo.name
+    if syminfo->has_key('containerName')
+      if syminfo.containerName != ''
+	name ..= $' [{syminfo.containerName}]'
+      endif
+    endif
+    r = syminfo.location.range
+    lspserver.decodeRange(bnr, r)
+
+    if !symbolTypeTable->has_key(symbolType)
+      symbolTypeTable[symbolType] = []
+    endif
+    symInfo = {name: name, range: r}
+    symbolTypeTable[symbolType]->add(symInfo)
+    symbolLineTable->add(symInfo)
+  endfor
+enddef
+
+# process DocumentSymbol[]
+def ProcessDocSymbolTable(lspserver: dict<any>,
+			  bnr: number,
+			  docSymbolTable: list<dict<any>>,
+			  symbolTypeTable: dict<list<dict<any>>>,
+			  symbolLineTable: list<dict<any>>)
+  var symbolType: string
+  var name: string
+  var r: dict<dict<number>>
+  var symInfo: dict<any>
+  var symbolDetail: string
+  var childSymbols: dict<list<dict<any>>>
+
+  for syminfo in docSymbolTable
+    name = syminfo.name
+    symbolType = SymbolKindToName(syminfo.kind)
+    r = syminfo.selectionRange
+    lspserver.decodeRange(bnr, r)
+    if syminfo->has_key('detail')
+      symbolDetail = syminfo.detail
+    endif
+    if !symbolTypeTable->has_key(symbolType)
+      symbolTypeTable[symbolType] = []
+    endif
+    childSymbols = {}
+    if syminfo->has_key('children')
+      ProcessDocSymbolTable(lspserver, bnr, syminfo.children, childSymbols,
+			    symbolLineTable)
+    endif
+    symInfo = {name: name, range: r, detail: symbolDetail,
+						children: childSymbols}
+    symbolTypeTable[symbolType]->add(symInfo)
+    symbolLineTable->add(symInfo)
+  endfor
+enddef
+
+# process the 'textDocument/documentSymbol' reply from the LSP server
+# Open a symbols window and display the symbols as a tree
+# Result: DocumentSymbol[] | SymbolInformation[] | null
+export def DocSymbolOutline(lspserver: dict<any>, docSymbol: any, fname: string)
+  var bnr = fname->bufnr()
+  var symbolTypeTable: dict<list<dict<any>>> = {}
+  var symbolLineTable: list<dict<any>> = []
+
+  if docSymbol->empty()
+    # No symbols defined for this file. Clear the outline window.
+    outline.UpdateOutlineWindow(fname, symbolTypeTable, symbolLineTable)
+    return
+  endif
+
+  if docSymbol[0]->has_key('location')
+    # SymbolInformation[]
+    ProcessSymbolInfoTable(lspserver, bnr, docSymbol, symbolTypeTable,
+			   symbolLineTable)
+  else
+    # DocumentSymbol[]
+    ProcessDocSymbolTable(lspserver, bnr, docSymbol, symbolTypeTable,
+			  symbolLineTable)
+  endif
+
+  # sort the symbols by line number
+  symbolLineTable->sort((a, b) => a.range.start.line - b.range.start.line)
+  outline.UpdateOutlineWindow(fname, symbolTypeTable, symbolLineTable)
+enddef
+
+# Process the list of symbols (LSP interface "SymbolInformation") in
+# "symbolInfoTable". For each symbol, create the name to display in the popup
+# menu along with the symbol range and return the List.
+def GetSymbolsInfoTable(lspserver: dict<any>,
+			bnr: number,
+			symbolInfoTable: list<dict<any>>): list<dict<any>>
+  var symbolTable: list<dict<any>> = []
+  var symbolType: string
+  var name: string
+  var containerName: string
+  var r: dict<dict<number>>
+
+  for syminfo in symbolInfoTable
+    symbolType = SymbolKindToName(syminfo.kind)
+    name = $'{symbolType} : {syminfo.name}'
+    if syminfo->has_key('containerName') && !syminfo.containerName->empty()
+      name ..= $' [{syminfo.containerName}]'
+    endif
+    r = syminfo.location.range
+    lspserver.decodeRange(bnr, r)
+
+    symbolTable->add({name: name, range: r, selectionRange: {}})
+  endfor
+
+  return symbolTable
+enddef
+
+# Process the list of symbols (LSP interface "DocumentSymbol") in
+# "docSymbolTable". For each symbol, create the name to display in the popup
+# menu along with the symbol range and return the List in "symbolTable"
+def GetSymbolsDocSymbol(lspserver: dict<any>,
+			bnr: number,
+			docSymbolTable: list<dict<any>>,
+			symbolTable: list<dict<any>>,
+			parentName: string = '')
+  var symbolType: string
+  var name: string
+  var r: dict<dict<number>>
+  var sr: dict<dict<number>>
+  var symInfo: dict<any>
+
+  for syminfo in docSymbolTable
+    var symName = syminfo.name
+    symbolType = SymbolKindToName(syminfo.kind)->tolower()
+    sr = syminfo.selectionRange
+    lspserver.decodeRange(bnr, sr)
+    r = syminfo.range
+    lspserver.decodeRange(bnr, r)
+    name = $'{symbolType} : {symName}'
+    if parentName != ''
+      name ..= $' [{parentName}]'
+    endif
+    # TODO: Should include syminfo.detail? Will it clutter the menu?
+    symInfo = {name: name, range: r, selectionRange: sr}
+    symbolTable->add(symInfo)
+
+    if syminfo->has_key('children')
+      # Process all the child symbols
+      GetSymbolsDocSymbol(lspserver, bnr, syminfo.children, symbolTable,
+			  symName)
+    endif
+  endfor
+enddef
+
+# Highlight the name and the range of lines for the symbol at symTbl[symIdx]
+def SymbolHighlight(symTbl: list<dict<any>>, symIdx: number)
+  prop_remove({type: 'LspSymbolNameProp', all: true})
+  prop_remove({type: 'LspSymbolRangeProp', all: true})
+  if symTbl->empty()
+    return
+  endif
+
+  var r = symTbl[symIdx].range
+  if r->empty()
+    return
+  endif
+  var rangeStart = r.start
+  var rangeEnd = r.end
+  var start_lnum = rangeStart.line + 1
+  var start_col = rangeStart.character + 1
+  var end_lnum = rangeEnd.line + 1
+  var end_col: number
+  var last_lnum = line('$')
+  if end_lnum > line('$')
+    end_lnum = last_lnum
+    end_col = col([last_lnum, '$'])
+  else
+    end_col = rangeEnd.character + 1
+  endif
+  prop_add(start_lnum, start_col,
+	   {type: 'LspSymbolRangeProp',
+	    end_lnum: end_lnum,
+	    end_col: end_col})
+  cursor(start_lnum, 1)
+  :normal! z.
+
+  var sr = symTbl[symIdx].selectionRange
+  if sr->empty()
+    return
+  endif
+  rangeStart = sr.start
+  rangeEnd = sr.end
+  prop_add(rangeStart.line + 1, 1,
+	   {type: 'LspSymbolNameProp',
+	    start_col: rangeStart.character + 1,
+	    end_lnum: rangeEnd.line + 1,
+	    end_col: rangeEnd.character + 1})
+enddef
+
+# Callback invoked when an item is selected in the symbol popup menu
+#   "symTbl" - list of symbols
+#   "symInputPopup" - Symbol search input popup window ID
+#   "save_curpos" - Cursor position before invoking the symbol search.  If the
+#		    symbol search is canceled, restore the cursor to this
+#		    position.
+def SymbolMenuItemSelected(symPopupMenu: number,
+			   result: number)
+  var symTblFiltered = symPopupMenu->getwinvar('symbolTableFiltered', [])
+  var symInputPopup = symPopupMenu->getwinvar('symbolInputPopup', 0)
+  var save_curpos = symPopupMenu->getwinvar('saveCurPos', [])
+
+  # Restore the cursor to the location where the command was invoked
+  setpos('.', save_curpos)
+
+  if result > 0
+    # A symbol is selected in the popup menu
+
+    # Set the previous cursor location mark. Instead of using setpos(), m' is
+    # used so that the current location is added to the jump list.
+    :normal m'
+
+    # Jump to the selected symbol location
+    var r = symTblFiltered[result - 1].selectionRange
+    if r->empty()
+      # SymbolInformation doesn't have the selectionRange field
+      r = symTblFiltered[result - 1].range
+    endif
+    setcursorcharpos(r.start.line + 1,
+		     util.GetCharIdxWithoutCompChar(bufnr(), r.start) + 1)
+    :normal! zv
+  endif
+  symInputPopup->popup_close()
+  prop_remove({type: 'LspSymbolNameProp', all: true})
+  prop_remove({type: 'LspSymbolRangeProp', all: true})
+enddef
+
+# Key filter function for the symbol popup menu.
+def SymbolMenuFilterKey(symPopupMenu: number,
+			key: string): bool
+  var keyHandled = true
+  var updateInputPopup = false
+  var inputText = symPopupMenu->getwinvar('inputText', '')
+  var symInputPopup = symPopupMenu->getwinvar('symbolInputPopup', 0)
+
+  if key == "\<BS>" || key == "\<C-H>"
+    # Erase a character in the input popup
+    if inputText->len() >= 1
+      inputText = inputText[: -2]
+      updateInputPopup = true
+    else
+      keyHandled = false
+    endif
+  elseif key == "\<C-U>"
+    # Erase all the characters in the input popup
+    inputText = ''
+    updateInputPopup = true
+  elseif key == "\<tab>"
+      || key == "\<C-n>"
+      || key == "\<Down>"
+      || key == "\<ScrollWheelDown>"
+    var ln = getcurpos(symPopupMenu)[1]
+    win_execute(symPopupMenu, "normal! j")
+    if ln == getcurpos(symPopupMenu)[1]
+      win_execute(symPopupMenu, "normal! gg")
+    endif
+  elseif key == "\<S-tab>"
+      || key == "\<C-p>"
+      || key == "\<Up>"
+      || key == "\<ScrollWheelUp>"
+    var ln = getcurpos(symPopupMenu)[1]
+    win_execute(symPopupMenu, "normal! k")
+    if ln == getcurpos(symPopupMenu)[1]
+      win_execute(symPopupMenu, "normal! G")
+    endif
+  elseif key == "\<PageDown>"
+    win_execute(symPopupMenu, "normal! \<C-d>")
+  elseif key == "\<PageUp>"
+    win_execute(symPopupMenu, "normal! \<C-u>")
+  elseif key == "\<C-F>"
+      || key == "\<C-B>"
+      || key == "\<C-Home>"
+      || key == "\<C-End>"
+    win_execute(symPopupMenu, $"normal! {key}")
+  elseif key =~ '^\k$'
+    # A keyword character is typed.  Add to the input text and update the
+    # popup
+    inputText ..= key
+    updateInputPopup = true
+  else
+    keyHandled = false
+  endif
+
+  var symTblFiltered: list<dict<any>> = []
+  symTblFiltered = symPopupMenu->getwinvar('symbolTableFiltered', [])
+
+  if updateInputPopup
+    # Update the input popup with the new text and update the symbol popup
+    # window with the matching symbol names.
+    symInputPopup->popup_settext(inputText)
+
+    var symbolTable = symPopupMenu->getwinvar('symbolTable')
+    symTblFiltered = symbolTable->deepcopy()
+    var symbolMatchPos: list<list<number>> = []
+
+    # Get the list of symbols fuzzy matching the entered text
+    if inputText != ''
+      var t = symTblFiltered->matchfuzzypos(inputText, {key: 'name'})
+      symTblFiltered = t[0]
+      symbolMatchPos = t[1]
+    endif
+
+    var popupText: list<dict<any>>
+    var text: list<dict<any>>
+    if !symbolMatchPos->empty()
+      # Generate a list of symbol names and the corresponding text properties
+      # to highlight the matching characters.
+      popupText = symTblFiltered->mapnew((idx, val): dict<any> => ({
+	text: val.name,
+	props: symbolMatchPos[idx]->mapnew((_, w: number): dict<any> => ({
+	  col: w + 1,
+	  length: 1,
+	  type: 'LspSymbolMatch'}
+        ))}
+      ))
+    else
+      popupText = symTblFiltered->mapnew((idx, val): dict<string> => {
+	return {text: val.name}
+      })
+    endif
+    symPopupMenu->popup_settext(popupText)
+
+    # Select the first symbol and highlight the corresponding text range
+    win_execute(symPopupMenu, 'cursor(1, 1)')
+    SymbolHighlight(symTblFiltered, 0)
+  endif
+
+  # Save the filtered symbol table and the search text in popup window
+  # variables
+  setwinvar(symPopupMenu, 'inputText', inputText)
+  setwinvar(symPopupMenu, 'symbolTableFiltered', symTblFiltered)
+
+  if !keyHandled
+    # Use the default handler for the key
+    symPopupMenu->popup_filter_menu(key)
+  endif
+
+  # Highlight the name and range of the selected symbol
+  var lnum = line('.', symPopupMenu) - 1
+  if lnum >= 0
+    SymbolHighlight(symTblFiltered, lnum)
+  endif
+
+  return true
+enddef
+
+# Display the symbols popup menu
+def SymbolPopupMenu(symbolTable: list<dict<any>>)
+  var curLine = line('.')
+  var curSymIdx = 0
+
+  # Get the names of all the symbols.  Also get the index of the symbol under
+  # the cursor.
+  var symNames = symbolTable->mapnew((idx, val): string => {
+    var r = val.range
+    if !r->empty() && curSymIdx == 0
+      if curLine >= r.start.line + 1 && curLine <= r.end.line + 1
+	curSymIdx = idx
+      endif
+    endif
+    return val.name
+  })
+
+  var symInputPopupAttr = {
+    title: 'Select Symbol',
+    wrap: false,
+    pos: 'topleft',
+    line: &lines - 14,
+    col: 10,
+    minwidth: 60,
+    minheight: 1,
+    maxheight: 1,
+    maxwidth: 60,
+    fixed: 1,
+    close: 'button',
+    border: []
+  }
+  var symInputPopup = popup_create('', symInputPopupAttr)
+
+  var symNamesPopupattr = {
+    wrap: false,
+    pos: 'topleft',
+    line: &lines - 11,
+    col: 10,
+    minwidth: 60,
+    minheight: 10,
+    maxheight: 10,
+    maxwidth: 60,
+    fixed: 1,
+    border: [0, 0, 0, 0],
+    callback: SymbolMenuItemSelected,
+    filter: SymbolMenuFilterKey,
+  }
+  var symPopupMenu = popup_menu(symNames, symNamesPopupattr)
+
+  # Save the state in the popup menu window variables
+  setwinvar(symPopupMenu, 'symbolTable', symbolTable)
+  setwinvar(symPopupMenu, 'symbolTableFiltered', symbolTable->deepcopy())
+  setwinvar(symPopupMenu, 'symbolInputPopup', symInputPopup)
+  setwinvar(symPopupMenu, 'saveCurPos', getcurpos())
+  prop_type_add('LspSymbolMatch', {bufnr: symPopupMenu->winbufnr(),
+				   highlight: 'Title',
+				   override: true})
+
+  # Start with the symbol under the cursor
+  var cmds =<< trim eval END
+    [{curSymIdx + 1}, 1]->cursor()
+    :normal! z.
+  END
+  win_execute(symPopupMenu, cmds, 'silent!')
+
+  # Highlight the name and range of the first symbol
+  SymbolHighlight(symbolTable, curSymIdx)
+enddef
+
+# process the 'textDocument/documentSymbol' reply from the LSP server
+# Result: DocumentSymbol[] | SymbolInformation[] | null
+# Display the symbols in a popup window and jump to the selected symbol
+export def DocSymbolPopup(lspserver: dict<any>, docSymbol: any, fname: string)
+  var symList: list<dict<any>> = []
+
+  if docSymbol->empty()
+    return
+  endif
+
+  var bnr = fname->bufnr()
+
+  if docSymbol[0]->has_key('location')
+    # SymbolInformation[]
+    symList = GetSymbolsInfoTable(lspserver, bnr, docSymbol)
+  else
+    # DocumentSymbol[]
+    GetSymbolsDocSymbol(lspserver, bnr, docSymbol, symList)
+  endif
+
+  :redraw!
+  SymbolPopupMenu(symList)
+enddef
+
+# vim: tabstop=8 shiftwidth=2 softtabstop=2
diff --git a/vim/pack/downloads/opt/lsp/autoload/lsp/textedit.vim b/vim/pack/downloads/opt/lsp/autoload/lsp/textedit.vim
new file mode 100644
index 0000000..ee4cc4a
--- /dev/null
+++ b/vim/pack/downloads/opt/lsp/autoload/lsp/textedit.vim
@@ -0,0 +1,321 @@
+vim9script
+
+import './util.vim'
+
+# sort the list of edit operations in the descending order of line and column
+# numbers.
+# 'a': {'A': [lnum, col], 'B': [lnum, col]}
+# 'b': {'A': [lnum, col], 'B': [lnum, col]}
+def Edit_sort_func(a: dict<any>, b: dict<any>): number
+  # line number
+  if a.A[0] != b.A[0]
+    return b.A[0] - a.A[0]
+  endif
+  # column number
+  if a.A[1] != b.A[1]
+    return b.A[1] - a.A[1]
+  endif
+
+  # Assume that the LSP sorted the lines correctly to begin with
+  return b.idx - a.idx
+enddef
+
+# Replaces text in a range with new text.
+#
+# CAUTION: Changes in-place!
+#
+# 'lines': Original list of strings
+# 'A': Start position; [line, col]
+# 'B': End position [line, col]
+# 'new_lines' A list of strings to replace the original
+#
+# returns the modified 'lines'
+def Set_lines(lines: list<string>, A: list<number>, B: list<number>,
+					new_lines: list<string>): list<string>
+  var i_0: number = A[0]
+
+  # If it extends past the end, truncate it to the end. This is because the
+  # way the LSP describes the range including the last newline is by
+  # specifying a line number after what we would call the last line.
+  var numlines: number = lines->len()
+  var i_n = [B[0], numlines - 1]->min()
+
+  if i_0 < 0 || i_0 >= numlines || i_n < 0 || i_n >= numlines
+    #util.WarnMsg("set_lines: Invalid range, A = " .. A->string()
+    #		.. ", B = " ..  B->string() .. ", numlines = " .. numlines
+    #		.. ", new lines = " .. new_lines->string())
+    var msg = $"set_lines: Invalid range, A = {A->string()}"
+    msg ..= $", B = {B->string()}, numlines = {numlines}"
+    msg ..= $", new lines = {new_lines->string()}"
+    util.WarnMsg(msg)
+    return lines
+  endif
+
+  # save the prefix and suffix text before doing the replacements
+  var prefix: string = ''
+  var suffix: string = lines[i_n][B[1] :]
+  if A[1] > 0
+    prefix = lines[i_0][0 : A[1] - 1]
+  endif
+
+  var new_lines_len: number = new_lines->len()
+
+  #echomsg $"i_0 = {i_0}, i_n = {i_n}, new_lines = {string(new_lines)}"
+  var n: number = i_n - i_0 + 1
+  if n != new_lines_len
+    if n > new_lines_len
+      # remove the deleted lines
+      lines->remove(i_0, i_0 + n - new_lines_len - 1)
+    else
+      # add empty lines for newly the added lines (will be replaced with the
+      # actual lines below)
+      lines->extend(repeat([''], new_lines_len - n), i_0)
+    endif
+  endif
+  #echomsg $"lines(1) = {string(lines)}"
+
+  # replace the previous lines with the new lines
+  for i in new_lines_len->range()
+    lines[i_0 + i] = new_lines[i]
+  endfor
+  #echomsg $"lines(2) = {string(lines)}"
+
+  # append the suffix (if any) to the last line
+  if suffix != ''
+    var i = i_0 + new_lines_len - 1
+    lines[i] = lines[i] .. suffix
+  endif
+  #echomsg $"lines(3) = {string(lines)}"
+
+  # prepend the prefix (if any) to the first line
+  if prefix != ''
+    lines[i_0] = prefix .. lines[i_0]
+  endif
+  #echomsg $"lines(4) = {string(lines)}"
+
+  return lines
+enddef
+
+# Apply set of text edits to the specified buffer
+# The text edit logic is ported from the Neovim lua implementation
+export def ApplyTextEdits(bnr: number, text_edits: list<dict<any>>): void
+  if text_edits->empty()
+    return
+  endif
+
+  # if the buffer is not loaded, load it and make it a listed buffer
+  :silent! bnr->bufload()
+  setbufvar(bnr, '&buflisted', true)
+
+  var start_line: number = 4294967295		# 2 ^ 32
+  var finish_line: number = -1
+  var updated_edits: list<dict<any>> = []
+  var start_row: number
+  var start_col: number
+  var end_row: number
+  var end_col: number
+
+  # create a list of buffer positions where the edits have to be applied.
+  var idx = 0
+  for e in text_edits
+    # Adjust the start and end columns for multibyte characters
+    var r = e.range
+    var rstart: dict<any> = r.start
+    var rend: dict<any> = r.end
+    start_row = rstart.line
+    start_col = util.GetCharIdxWithoutCompChar(bnr, rstart)
+    end_row = rend.line
+    end_col = util.GetCharIdxWithoutCompChar(bnr, rend)
+    start_line = [rstart.line, start_line]->min()
+    finish_line = [rend.line, finish_line]->max()
+
+    updated_edits->add({A: [start_row, start_col],
+			B: [end_row, end_col],
+                        idx: idx,
+			lines: e.newText->split("\n", true)})
+    idx += 1
+  endfor
+
+  # Reverse sort the edit operations by descending line and column numbers so
+  # that they can be applied without interfering with each other.
+  updated_edits->sort('Edit_sort_func')
+
+  var lines: list<string> = bnr->getbufline(start_line + 1, finish_line + 1)
+  var fix_eol: bool = bnr->getbufvar('&fixeol')
+  var set_eol = fix_eol && bnr->getbufinfo()[0].linecount <= finish_line + 1
+  if !lines->empty() && set_eol && lines[-1]->len() != 0
+    lines->add('')
+  endif
+
+  #echomsg $'lines(1) = {string(lines)}'
+  #echomsg updated_edits
+
+  for e in updated_edits
+    var A: list<number> = [e.A[0] - start_line, e.A[1]]
+    var B: list<number> = [e.B[0] - start_line, e.B[1]]
+    lines = Set_lines(lines, A, B, e.lines)
+  endfor
+
+  #echomsg $'lines(2) = {string(lines)}'
+
+  # If the last line is empty and we need to set EOL, then remove it.
+  if !lines->empty() && set_eol && lines[-1]->len() == 0
+    lines->remove(-1)
+  endif
+
+  #echomsg $'ApplyTextEdits: start_line = {start_line}, finish_line = {finish_line}'
+  #echomsg $'lines = {string(lines)}'
+
+  # if the buffer is empty, appending lines before the first line adds an
+  # extra empty line at the end. Delete the empty line after appending the
+  # lines.
+  var dellastline: bool = false
+  if start_line == 0 && bnr->getbufinfo()[0].linecount == 1 &&
+					bnr->getbufline(1)->get(0, '')->empty()
+    dellastline = true
+  endif
+
+  # Now we apply the textedits to the actual buffer.
+  # In theory we could just delete all old lines and append the new lines.
+  # This would however cause the cursor to change position: It will always be
+  # on the last line added.
+  #
+  # Luckily there is an even simpler solution, that has no cursor sideeffects.
+  #
+  # Logically this method is split into the following three cases:
+  #
+  # 1. The number of new lines is equal to the number of old lines:
+  #    Just replace the lines inline with setbufline()
+  #
+  # 2. The number of new lines is greater than the old ones:
+  #    First append the missing lines at the **end** of the range, then use
+  #    setbufline() again. This does not cause the cursor to change position.
+  #
+  # 3. The number of new lines is less than before:
+  #    First use setbufline() to replace the lines that we can replace.
+  #    Then remove superfluous lines.
+  #
+  # Luckily, the three different cases exist only logically, we can reduce
+  # them to a single case practically, because appendbufline() does not append
+  # anything if an empty list is passed just like deletebufline() does not
+  # delete anything, if the last line of the range is before the first line.
+  # We just need to be careful with all indices.
+  appendbufline(bnr, finish_line + 1, lines[finish_line - start_line + 1 : -1])
+  setbufline(bnr, start_line + 1, lines)
+  deletebufline(bnr, start_line + 1 + lines->len(), finish_line + 1)
+
+  if dellastline
+    bnr->deletebufline(bnr->getbufinfo()[0].linecount)
+  endif
+enddef
+
+# interface TextDocumentEdit
+def ApplyTextDocumentEdit(textDocEdit: dict<any>)
+  var bnr: number = util.LspUriToBufnr(textDocEdit.textDocument.uri)
+  if bnr == -1
+    util.ErrMsg($'Text Document edit, buffer {textDocEdit.textDocument.uri} is not found')
+    return
+  endif
+  ApplyTextEdits(bnr, textDocEdit.edits)
+enddef
+
+# interface CreateFile
+# Create the "createFile.uri" file
+def FileCreate(createFile: dict<any>)
+  var fname: string = util.LspUriToFile(createFile.uri)
+  var opts: dict<bool> = createFile->get('options', {})
+  var ignoreIfExists: bool = opts->get('ignoreIfExists', true)
+  var overwrite: bool = opts->get('overwrite', false)
+
+  # LSP Spec: Overwrite wins over `ignoreIfExists`
+  if fname->filereadable() && ignoreIfExists && !overwrite
+    return
+  endif
+
+  fname->fnamemodify(':p:h')->mkdir('p')
+  []->writefile(fname)
+  fname->bufadd()
+enddef
+
+# interface DeleteFile
+# Delete the "deleteFile.uri" file
+def FileDelete(deleteFile: dict<any>)
+  var fname: string = util.LspUriToFile(deleteFile.uri)
+  var opts: dict<bool> = deleteFile->get('options', {})
+  var recursive: bool = opts->get('recursive', false)
+  var ignoreIfNotExists: bool = opts->get('ignoreIfNotExists', true)
+
+  if !fname->filereadable() && ignoreIfNotExists
+    return
+  endif
+
+  var flags: string = ''
+  if recursive
+    # # NOTE: is this a dangerous operation?  The LSP server can send a
+    # # DeleteFile message to recursively delete all the files in the disk.
+    # flags = 'rf'
+    util.ErrMsg($'Recursively deleting files is not supported')
+    return
+  elseif fname->isdirectory()
+    flags = 'd'
+  endif
+  var bnr: number = fname->bufadd()
+  fname->delete(flags)
+  exe $'{bnr}bwipe!'
+enddef
+
+# interface RenameFile
+# Rename file "renameFile.oldUri" to "renameFile.newUri"
+def FileRename(renameFile: dict<any>)
+  var old_fname: string = util.LspUriToFile(renameFile.oldUri)
+  var new_fname: string = util.LspUriToFile(renameFile.newUri)
+
+  var opts: dict<bool> = renameFile->get('options', {})
+  var overwrite: bool = opts->get('overwrite', false)
+  var ignoreIfExists: bool = opts->get('ignoreIfExists', true)
+
+  if new_fname->filereadable() && (!overwrite || ignoreIfExists)
+    return
+  endif
+
+  old_fname->rename(new_fname)
+enddef
+
+# interface WorkspaceEdit
+export def ApplyWorkspaceEdit(workspaceEdit: dict<any>)
+  if workspaceEdit->has_key('documentChanges')
+    for change in workspaceEdit.documentChanges
+      if change->has_key('kind')
+	if change.kind == 'create'
+	  FileCreate(change)
+	elseif change.kind == 'delete'
+	  FileDelete(change)
+	elseif change.kind == 'rename'
+	  FileRename(change)
+	else
+	  util.ErrMsg($'Unsupported change in workspace edit [{change.kind}]')
+	endif
+      else
+	ApplyTextDocumentEdit(change)
+      endif
+    endfor
+    return
+  endif
+
+  if !workspaceEdit->has_key('changes')
+    return
+  endif
+
+  for [uri, changes] in workspaceEdit.changes->items()
+    var bnr: number = util.LspUriToBufnr(uri)
+    if bnr == 0
+      # file is not present
+      continue
+    endif
+
+    # interface TextEdit
+    ApplyTextEdits(bnr, changes)
+  endfor
+enddef
+
+# vim: tabstop=8 shiftwidth=2 softtabstop=2
diff --git a/vim/pack/downloads/opt/lsp/autoload/lsp/typehierarchy.vim b/vim/pack/downloads/opt/lsp/autoload/lsp/typehierarchy.vim
new file mode 100644
index 0000000..8786b1b
--- /dev/null
+++ b/vim/pack/downloads/opt/lsp/autoload/lsp/typehierarchy.vim
@@ -0,0 +1,174 @@
+vim9script
+
+# Functions for dealing with type hierarchy (super types/sub types)
+
+import './util.vim'
+import './symbol.vim'
+
+# Parse the type hierarchy in "typeHier" and displays a tree of type names
+# in the current buffer.  This function is called recursively to display the
+# super/sub type hierarchy.
+#
+# Returns the line number where the next type name should be added.
+def TypeTreeGenerate(isSuper: bool, typeHier: dict<any>, pfx_arg: string,
+			typeTree: list<string>, typeUriMap: list<dict<any>>)
+
+  var itemHasChildren = false
+  if isSuper
+    if typeHier->has_key('parents') && !typeHier.parents->empty()
+      itemHasChildren = true
+    endif
+  else
+    if typeHier->has_key('children') && !typeHier.children->empty()
+      itemHasChildren = true
+    endif
+  endif
+
+  var itemBranchPfx: string
+  if itemHasChildren
+    itemBranchPfx = '▾ '
+  else
+    itemBranchPfx = pfx_arg->empty() ? '' : '  '
+  endif
+
+  var typestr: string
+  var kindstr = symbol.SymbolKindToName(typeHier.kind)
+  if kindstr != ''
+    typestr = $'{pfx_arg}{itemBranchPfx}{typeHier.name} ({kindstr[0]})'
+  else
+    typestr = $'{pfx_arg}{itemBranchPfx}{typeHier.name}'
+  endif
+  typeTree->add(typestr)
+  typeUriMap->add(typeHier)
+
+  # last item to process
+  if !itemHasChildren
+    return
+  endif
+
+  var items: list<dict<any>>
+  items = isSuper ? typeHier.parents : typeHier.children
+
+  for item in items
+    TypeTreeGenerate(isSuper, item, $'{pfx_arg}| ', typeTree, typeUriMap)
+  endfor
+enddef
+
+# Display a popup with the file containing a type and highlight the line and
+# the type name.
+def UpdateTypeHierFileInPopup(lspserver: dict<any>, typeUriMap: list<dict<any>>)
+  if lspserver.typeHierPopup->winbufnr() == -1
+    return
+  endif
+
+  lspserver.typeHierFilePopup->popup_close()
+
+  var n = line('.', lspserver.typeHierPopup) - 1
+  var fname: string = util.LspUriToFile(typeUriMap[n].uri)
+
+  var bnr = fname->bufadd()
+  if bnr == 0
+    return
+  endif
+
+  var popupAttrs = {
+    title: $"{fname->fnamemodify(':t')} ({fname->fnamemodify(':h')})",
+    wrap: false,
+    fixed: true,
+    minheight: 10,
+    maxheight: 10,
+    minwidth: winwidth(0) - 38,
+    maxwidth: winwidth(0) - 38,
+    cursorline: true,
+    border: [],
+    line: 'cursor+1',
+    col: 1
+  }
+  lspserver.typeHierFilePopup = popup_create(bnr, popupAttrs)
+  var cmds =<< trim eval END
+    [{typeUriMap[n].range.start.line + 1}, 1]->cursor()
+    :normal! z.
+  END
+  win_execute(lspserver.typeHierFilePopup, cmds)
+
+  lspserver.typeHierFilePopup->clearmatches()
+  var start_col = util.GetLineByteFromPos(bnr,
+					typeUriMap[n].selectionRange.start) + 1
+  var end_col = util.GetLineByteFromPos(bnr, typeUriMap[n].selectionRange.end)
+  var pos = [[typeUriMap[n].selectionRange.start.line + 1,
+	     start_col, end_col - start_col + 1]]
+  matchaddpos('Search', pos, 10, -1, {window: lspserver.typeHierFilePopup})
+enddef
+
+def TypeHierPopupFilter(lspserver: dict<any>, typeUriMap: list<dict<any>>,
+			popupID: number, key: string): bool
+  popupID->popup_filter_menu(key)
+  if lspserver.typeHierPopup->winbufnr() == -1
+    # popup is closed
+    if lspserver.typeHierFilePopup->winbufnr() != -1
+      lspserver.typeHierFilePopup->popup_close()
+    endif
+    lspserver.typeHierFilePopup = -1
+    lspserver.typeHierPopup = -1
+  else
+    UpdateTypeHierFileInPopup(lspserver, typeUriMap)
+  endif
+
+  return true
+enddef
+
+def TypeHierPopupCallback(lspserver: dict<any>, typeUriMap: list<dict<any>>,
+			  popupID: number, selIdx: number)
+  if lspserver.typeHierFilePopup->winbufnr() != -1
+    lspserver.typeHierFilePopup->popup_close()
+  endif
+  lspserver.typeHierFilePopup = -1
+  lspserver.typeHierPopup = -1
+
+  if selIdx <= 0
+    # popup is canceled
+    return
+  endif
+
+  # Save the current cursor location in the tag stack.
+  util.PushCursorToTagStack()
+  util.JumpToLspLocation(typeUriMap[selIdx - 1], '')
+enddef
+
+# Show the super or sub type hierarchy items "types" as a tree in a popup
+# window
+export def ShowTypeHierarchy(lspserver: dict<any>, isSuper: bool, types: dict<any>)
+
+  if lspserver.typeHierPopup->winbufnr() != -1
+    # If the type hierarchy popup window is already present, close it.
+    lspserver.typeHierPopup->popup_close()
+  endif
+
+  var typeTree: list<string>
+  var typeUriMap: list<dict<any>>
+
+  # Generate a tree of the type hierarchy items
+  TypeTreeGenerate(isSuper, types, '', typeTree, typeUriMap)
+
+  # Display a popup window with the type hierarchy tree and a popup window for
+  # the file.
+  var popupAttrs = {
+      title: $'{isSuper ? "Super" : "Sub"}Type Hierarchy',
+      wrap: 0,
+      pos: 'topleft',
+      line: 'cursor+1',
+      col: winwidth(0) - 34,
+      minheight: 10,
+      maxheight: 10,
+      minwidth: 30,
+      maxwidth: 30,
+      mapping: false,
+      fixed: true,
+      filter: function(TypeHierPopupFilter, [lspserver, typeUriMap]),
+      callback: function(TypeHierPopupCallback, [lspserver, typeUriMap])
+    }
+  lspserver.typeHierPopup = popup_menu(typeTree, popupAttrs)
+  UpdateTypeHierFileInPopup(lspserver, typeUriMap)
+enddef
+
+# vim: tabstop=8 shiftwidth=2 softtabstop=2
diff --git a/vim/pack/downloads/opt/lsp/autoload/lsp/util.vim b/vim/pack/downloads/opt/lsp/autoload/lsp/util.vim
new file mode 100644
index 0000000..eb0a64f
--- /dev/null
+++ b/vim/pack/downloads/opt/lsp/autoload/lsp/util.vim
@@ -0,0 +1,364 @@
+vim9script
+
+# Display an info message
+export def InfoMsg(msg: string)
+  :echohl Question
+  :echomsg $'Info: {msg}'
+  :echohl None
+enddef
+
+# Display a warning message
+export def WarnMsg(msg: string)
+  :echohl WarningMsg
+  :echomsg $'Warn: {msg}'
+  :echohl None
+enddef
+
+# Display an error message
+export def ErrMsg(msg: string)
+  :echohl Error
+  :echomsg $'Error: {msg}'
+  :echohl None
+enddef
+
+# Lsp server trace log directory
+var lsp_log_dir: string
+if has('unix')
+  lsp_log_dir = '/tmp/'
+else
+  lsp_log_dir = $TEMP .. '\\'
+endif
+
+# Log a message from the LSP server. stderr is true for logging messages
+# from the standard error and false for stdout.
+export def TraceLog(fname: string, stderr: bool, msg: string)
+  if stderr
+    writefile(msg->split("\n"), $'{lsp_log_dir}{fname}', 'a')
+  else
+    writefile([msg], $'{lsp_log_dir}{fname}', 'a')
+  endif
+enddef
+
+# Empty out the LSP server trace logs
+export def ClearTraceLogs(fname: string)
+  writefile([], $'{lsp_log_dir}{fname}')
+enddef
+
+# Open the LSP server debug messages file.
+export def ServerMessagesShow(fname: string)
+  var fullname = $'{lsp_log_dir}{fname}'
+  if !filereadable(fullname)
+    WarnMsg($'File {fullname} is not found')
+    return
+  endif
+  var wid = fullname->bufwinid()
+  if wid == -1
+    exe $'split {fullname}'
+  else
+    win_gotoid(wid)
+  endif
+  setlocal autoread
+  setlocal bufhidden=wipe
+  setlocal nomodified
+  setlocal nomodifiable
+enddef
+
+# Parse a LSP Location or LocationLink type and return a List with two items.
+# The first item is the DocumentURI and the second item is the Range.
+export def LspLocationParse(lsploc: dict<any>): list<any>
+  if lsploc->has_key('targetUri')
+    # LocationLink
+    return [lsploc.targetUri, lsploc.targetSelectionRange]
+  else
+    # Location
+    return [lsploc.uri, lsploc.range]
+  endif
+enddef
+
+# Convert a LSP file URI (file://<absolute_path>) to a Vim file name
+export def LspUriToFile(uri: string): string
+  # Replace all the %xx numbers (e.g. %20 for space) in the URI to character
+  var uri_decoded: string = substitute(uri, '%\(\x\x\)',
+				'\=nr2char(str2nr(submatch(1), 16))', 'g')
+
+  # File URIs on MS-Windows start with file:///[a-zA-Z]:'
+  if uri_decoded =~? '^file:///\a:'
+    # MS-Windows URI
+    uri_decoded = uri_decoded[8 : ]
+    uri_decoded = uri_decoded->substitute('/', '\\', 'g')
+  # On GNU/Linux (pattern not end with `:`)
+  elseif uri_decoded =~? '^file:///\a'
+    uri_decoded = uri_decoded[7 : ]
+  endif
+
+  return uri_decoded
+enddef
+
+# Convert a LSP file URI (file://<absolute_path>) to a Vim buffer number.
+# If the file is not in a Vim buffer, then adds the buffer.
+# Returns 0 on error.
+export def LspUriToBufnr(uri: string): number
+  return LspUriToFile(uri)->bufadd()
+enddef
+
+# Returns if the URI refers to a remote file (e.g. ssh://)
+# Credit: vim-lsp plugin
+export def LspUriRemote(uri: string): bool
+  return uri =~ '^\w\+::' || uri =~ '^[a-z][a-z0-9+.-]*://'
+enddef
+
+var resolvedUris = {}
+
+# Convert a Vim filename to an LSP URI (file://<absolute_path>)
+export def LspFileToUri(fname: string): string
+  var fname_full: string = fname->fnamemodify(':p')
+
+  if resolvedUris->has_key(fname_full)
+    return resolvedUris[fname_full]
+  endif
+
+  var uri: string = fname_full
+
+  if has("win32unix")
+    # We're in Cygwin, convert POSIX style paths to Windows style.
+    # The substitution is to remove the '^@' escape character from the end of
+    # line.
+    uri = system($'cygpath -m {uri}')->substitute('^\(\p*\).*$', '\=submatch(1)', "")
+  endif
+
+  var on_windows: bool = false
+  if uri =~? '^\a:'
+    on_windows = true
+  endif
+
+  if on_windows
+    # MS-Windows
+    uri = uri->substitute('\\', '/', 'g')
+  endif
+
+  uri = uri->substitute('\([^A-Za-z0-9-._~:/]\)',
+			'\=printf("%%%02x", char2nr(submatch(1)))', 'g')
+
+  if on_windows
+    uri = $'file:///{uri}'
+  else
+    uri = $'file://{uri}'
+  endif
+
+  resolvedUris[fname_full] = uri
+  return uri
+enddef
+
+# Convert a Vim buffer number to an LSP URI (file://<absolute_path>)
+export def LspBufnrToUri(bnr: number): string
+  return LspFileToUri(bnr->bufname())
+enddef
+
+# Returns the byte number of the specified LSP position in buffer "bnr".
+# LSP's line and characters are 0-indexed.
+# Vim's line and columns are 1-indexed.
+# Returns a zero-indexed column.
+export def GetLineByteFromPos(bnr: number, pos: dict<number>): number
+  var col: number = pos.character
+  # When on the first character, we can ignore the difference between byte and
+  # character
+  if col <= 0
+    return col
+  endif
+
+  # Need a loaded buffer to read the line and compute the offset
+  :silent! bnr->bufload()
+
+  var ltext: string = bnr->getbufline(pos.line + 1)->get(0, '')
+  if ltext->empty()
+    return col
+  endif
+
+  var byteIdx = ltext->byteidxcomp(col)
+  if byteIdx != -1
+    return byteIdx
+  endif
+
+  return col
+enddef
+
+# Get the index of the character at [pos.line, pos.character] in buffer "bnr"
+# without counting the composing characters.  The LSP server counts composing
+# characters as separate characters whereas Vim string indexing ignores the
+# composing characters.
+export def GetCharIdxWithoutCompChar(bnr: number, pos: dict<number>): number
+  var col: number = pos.character
+  # When on the first character, nothing to do.
+  if col <= 0
+    return col
+  endif
+
+  # Need a loaded buffer to read the line and compute the offset
+  :silent! bnr->bufload()
+
+  var ltext: string = bnr->getbufline(pos.line + 1)->get(0, '')
+  if ltext->empty()
+    return col
+  endif
+
+  # Convert the character index that includes composing characters as separate
+  # characters to a byte index and then back to a character index ignoring the
+  # composing characters.
+  var byteIdx = ltext->byteidxcomp(col)
+  if byteIdx != -1
+    if byteIdx == ltext->strlen()
+      # Byte index points to the byte after the last byte.
+      return ltext->strcharlen()
+    else
+      return ltext->charidx(byteIdx, false)
+    endif
+  endif
+
+  return col
+enddef
+
+# Get the index of the character at [pos.line, pos.character] in buffer "bnr"
+# counting the composing characters as separate characters.  The LSP server
+# counts composing characters as separate characters whereas Vim string
+# indexing ignores the composing characters.
+export def GetCharIdxWithCompChar(ltext: string, charIdx: number): number
+  # When on the first character, nothing to do.
+  if charIdx <= 0 || ltext->empty()
+    return charIdx
+  endif
+
+  # Convert the character index that doesn't include composing characters as
+  # separate characters to a byte index and then back to a character index
+  # that includes the composing characters as separate characters
+  var byteIdx = ltext->byteidx(charIdx)
+  if byteIdx != -1
+    if byteIdx == ltext->strlen()
+      return ltext->strchars()
+    else
+      return ltext->charidx(byteIdx, true)
+    endif
+  endif
+
+  return charIdx
+enddef
+
+# push the current location on to the tag stack
+export def PushCursorToTagStack()
+  settagstack(winnr(), {items: [
+			 {
+			   bufnr: bufnr(),
+			   from: getpos('.'),
+			   matchnr: 1,
+			   tagname: expand('<cword>')
+			 }]}, 't')
+enddef
+
+# Jump to the LSP "location".  The "location" contains the file name, line
+# number and character number. The user specified window command modifiers
+# (e.g. topleft) are in "cmdmods".
+export def JumpToLspLocation(location: dict<any>, cmdmods: string)
+  var [uri, range] = LspLocationParse(location)
+  var fname = LspUriToFile(uri)
+
+  # jump to the file and line containing the symbol
+  var bnr: number = fname->bufnr()
+  if cmdmods->empty()
+    if bnr == bufnr()
+      # Set the previous cursor location mark. Instead of using setpos(), m' is
+      # used so that the current location is added to the jump list.
+      :normal m'
+    else
+      var wid = fname->bufwinid()
+      if wid != -1
+        wid->win_gotoid()
+      else
+        if bnr != -1
+          # Reuse an existing buffer. If the current buffer has unsaved changes
+          # and 'hidden' is not set or if the current buffer is a special
+          # buffer, then open the buffer in a new window.
+          if (&modified && !&hidden) || &buftype != ''
+            exe $'belowright sbuffer {bnr}'
+          else
+            exe $'buf {bnr}'
+          endif
+        else
+          if (&modified && !&hidden) || &buftype != ''
+            # if the current buffer has unsaved changes and 'hidden' is not set,
+            # or if the current buffer is a special buffer, then open the file
+            # in a new window
+            exe $'belowright split {fname}'
+          else
+            exe $'edit {fname}'
+          endif
+        endif
+      endif
+    endif
+  else
+    if bnr == -1
+      exe $'{cmdmods} split {fname}'
+    else
+      # Use "sbuffer" so that the 'switchbuf' option settings are used.
+      exe $'{cmdmods} sbuffer {bnr}'
+    endif
+  endif
+  var rstart = range.start
+  setcursorcharpos(rstart.line + 1,
+		   GetCharIdxWithoutCompChar(bufnr(), rstart) + 1)
+  :normal! zv
+enddef
+
+# indexof() function is not present in older Vim 9 versions.  So use this
+# function.
+export def Indexof(list: list<any>, CallbackFn: func(number, any): bool): number
+  var ix = 0
+  for val in list
+    if CallbackFn(ix, val)
+      return ix
+    endif
+    ix += 1
+  endfor
+  return -1
+enddef
+
+# Find the nearest root directory containing a file or directory name from the
+# list of names in "files" starting with the directory "startDir".
+# Based on a similar implementation in the vim-lsp plugin.
+# Searches upwards starting with the directory "startDir".
+# If a file name ends with '/' or '\', then it is a directory name, otherwise
+# it is a file name.
+# Returns '' if none of the file and directory names in "files" can be found
+# in one of the parent directories.
+export def FindNearestRootDir(startDir: string, files: list<any>): string
+  var foundDirs: dict<bool> = {}
+
+  for file in files
+    if file->type() != v:t_string || file->empty()
+      continue
+    endif
+    var isDir = file[-1 : ] == '/' || file[-1 : ] == '\'
+    var relPath: string
+    if isDir
+      relPath = finddir(file, $'{startDir};')
+    else
+      relPath = findfile(file, $'{startDir};')
+    endif
+    if relPath->empty()
+      continue
+    endif
+    var rootDir = relPath->fnamemodify(isDir ? ':p:h:h' : ':p:h')
+    foundDirs[rootDir] = true
+  endfor
+  if foundDirs->empty()
+    return ''
+  endif
+
+  # Sort the directory names by length
+  var sortedList: list<string> = foundDirs->keys()->sort((a, b) => {
+    return b->len() - a->len()
+  })
+
+  # choose the longest matching path (the nearest directory from "startDir")
+  return sortedList[0]
+enddef
+
+# vim: tabstop=8 shiftwidth=2 softtabstop=2